#pragma once

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

// Package: InterchangeEngine

#include "Basic.hpp"

#include "InterchangeEngine_classes.hpp"
#include "InterchangeEngine_parameters.hpp"


SDK_NAMESPACE_START

// Function InterchangeEngine.InterchangeFilePickerBase.ScriptedFilePickerForTranslatorAssetType
// (RequiredAPI, Native, Event, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// const EInterchangeTranslatorAssetType   TranslatorAssetType                                    (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FInterchangeFilePickerParameters*Parameters                                             (Parm, OutParm, NativeAccessSpecifierPublic)
// TArray<class FString>*                  OutFilenames                                           (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeFilePickerBase::ScriptedFilePickerForTranslatorAssetType(const EInterchangeTranslatorAssetType TranslatorAssetType, struct FInterchangeFilePickerParameters* Parameters, TArray<class FString>* OutFilenames)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeFilePickerBase", "ScriptedFilePickerForTranslatorAssetType");

	Params::InterchangeFilePickerBase_ScriptedFilePickerForTranslatorAssetType Parms{};

	Parms.TranslatorAssetType = TranslatorAssetType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Parameters != nullptr)
		*Parameters = std::move(Parms.Parameters);

	if (OutFilenames != nullptr)
		*OutFilenames = std::move(Parms.OutFilenames);

	return Parms.ReturnValue;
}


// Function InterchangeEngine.InterchangeFilePickerBase.ScriptedFilePickerForTranslatorType
// (RequiredAPI, Native, Event, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// const EInterchangeTranslatorType        TranslatorType                                         (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// struct FInterchangeFilePickerParameters*Parameters                                             (Parm, OutParm, NativeAccessSpecifierPublic)
// TArray<class FString>*                  OutFilenames                                           (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeFilePickerBase::ScriptedFilePickerForTranslatorType(const EInterchangeTranslatorType TranslatorType, struct FInterchangeFilePickerParameters* Parameters, TArray<class FString>* OutFilenames)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeFilePickerBase", "ScriptedFilePickerForTranslatorType");

	Params::InterchangeFilePickerBase_ScriptedFilePickerForTranslatorType Parms{};

	Parms.TranslatorType = TranslatorType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (Parameters != nullptr)
		*Parameters = std::move(Parms.Parameters);

	if (OutFilenames != nullptr)
		*OutFilenames = std::move(Parms.OutFilenames);

	return Parms.ReturnValue;
}


// Function InterchangeEngine.InterchangePipelineConfigurationBase.ScriptedShowPipelineConfigurationDialog
// (RequiredAPI, Native, Event, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// TArray<struct FInterchangeStackInfo>*   PipelineStacks                                         (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// TArray<class UInterchangePipelineBase*>*OutPipelines                                           (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// class UInterchangeSourceData*           SourceData                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UInterchangeTranslatorBase*       Translator                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UInterchangeBaseNodeContainer*    BaseNodeContainer                                      (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EInterchangePipelineConfigurationDialogResultReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EInterchangePipelineConfigurationDialogResult UInterchangePipelineConfigurationBase::ScriptedShowPipelineConfigurationDialog(TArray<struct FInterchangeStackInfo>* PipelineStacks, TArray<class UInterchangePipelineBase*>* OutPipelines, class UInterchangeSourceData* SourceData, class UInterchangeTranslatorBase* Translator, class UInterchangeBaseNodeContainer* BaseNodeContainer)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangePipelineConfigurationBase", "ScriptedShowPipelineConfigurationDialog");

	Params::InterchangePipelineConfigurationBase_ScriptedShowPipelineConfigurationDialog Parms{};

	Parms.SourceData = SourceData;
	Parms.Translator = Translator;
	Parms.BaseNodeContainer = BaseNodeContainer;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (PipelineStacks != nullptr)
		*PipelineStacks = std::move(Parms.PipelineStacks);

	if (OutPipelines != nullptr)
		*OutPipelines = std::move(Parms.OutPipelines);

	return Parms.ReturnValue;
}


// Function InterchangeEngine.InterchangePipelineConfigurationBase.ScriptedShowReimportPipelineConfigurationDialog
// (RequiredAPI, Native, Event, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// TArray<struct FInterchangeStackInfo>*   PipelineStacks                                         (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// TArray<class UInterchangePipelineBase*>*OutPipelines                                           (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// class UInterchangeSourceData*           SourceData                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UInterchangeTranslatorBase*       Translator                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UInterchangeBaseNodeContainer*    BaseNodeContainer                                      (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          ReimportAsset                                          (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bSceneImport                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EInterchangePipelineConfigurationDialogResultReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EInterchangePipelineConfigurationDialogResult UInterchangePipelineConfigurationBase::ScriptedShowReimportPipelineConfigurationDialog(TArray<struct FInterchangeStackInfo>* PipelineStacks, TArray<class UInterchangePipelineBase*>* OutPipelines, class UInterchangeSourceData* SourceData, class UInterchangeTranslatorBase* Translator, class UInterchangeBaseNodeContainer* BaseNodeContainer, class UObject* ReimportAsset, bool bSceneImport)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangePipelineConfigurationBase", "ScriptedShowReimportPipelineConfigurationDialog");

	Params::InterchangePipelineConfigurationBase_ScriptedShowReimportPipelineConfigurationDialog Parms{};

	Parms.SourceData = SourceData;
	Parms.Translator = Translator;
	Parms.BaseNodeContainer = BaseNodeContainer;
	Parms.ReimportAsset = ReimportAsset;
	Parms.bSceneImport = bSceneImport;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (PipelineStacks != nullptr)
		*PipelineStacks = std::move(Parms.PipelineStacks);

	if (OutPipelines != nullptr)
		*OutPipelines = std::move(Parms.OutPipelines);

	return Parms.ReturnValue;
}


// Function InterchangeEngine.InterchangePipelineConfigurationBase.ScriptedShowScenePipelineConfigurationDialog
// (RequiredAPI, Native, Event, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// TArray<struct FInterchangeStackInfo>*   PipelineStacks                                         (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// TArray<class UInterchangePipelineBase*>*OutPipelines                                           (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// class UInterchangeSourceData*           SourceData                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UInterchangeTranslatorBase*       Translator                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UInterchangeBaseNodeContainer*    BaseNodeContainer                                      (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EInterchangePipelineConfigurationDialogResultReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EInterchangePipelineConfigurationDialogResult UInterchangePipelineConfigurationBase::ScriptedShowScenePipelineConfigurationDialog(TArray<struct FInterchangeStackInfo>* PipelineStacks, TArray<class UInterchangePipelineBase*>* OutPipelines, class UInterchangeSourceData* SourceData, class UInterchangeTranslatorBase* Translator, class UInterchangeBaseNodeContainer* BaseNodeContainer)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangePipelineConfigurationBase", "ScriptedShowScenePipelineConfigurationDialog");

	Params::InterchangePipelineConfigurationBase_ScriptedShowScenePipelineConfigurationDialog Parms{};

	Parms.SourceData = SourceData;
	Parms.Translator = Translator;
	Parms.BaseNodeContainer = BaseNodeContainer;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (PipelineStacks != nullptr)
		*PipelineStacks = std::move(Parms.PipelineStacks);

	if (OutPipelines != nullptr)
		*OutPipelines = std::move(Parms.OutPipelines);

	return Parms.ReturnValue;
}


// Function InterchangeEngine.InterchangePipelineConfigurationBase.ScriptedShowTestPlanConfigurationDialog
// (RequiredAPI, Native, Event, Public, HasOutParams, BlueprintCallable, BlueprintEvent)
// Parameters:
// TArray<struct FInterchangeStackInfo>*   PipelineStacks                                         (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// TArray<class UInterchangePipelineBase*>*OutPipelines                                           (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// class UInterchangeSourceData*           SourceData                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UInterchangeTranslatorBase*       Translator                                             (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UInterchangeBaseNodeContainer*    BaseNodeContainer                                      (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UObject*                          ReimportAsset                                          (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bSceneImport                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bReimport                                              (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// EInterchangePipelineConfigurationDialogResultReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

EInterchangePipelineConfigurationDialogResult UInterchangePipelineConfigurationBase::ScriptedShowTestPlanConfigurationDialog(TArray<struct FInterchangeStackInfo>* PipelineStacks, TArray<class UInterchangePipelineBase*>* OutPipelines, class UInterchangeSourceData* SourceData, class UInterchangeTranslatorBase* Translator, class UInterchangeBaseNodeContainer* BaseNodeContainer, class UObject* ReimportAsset, bool bSceneImport, bool bReimport)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangePipelineConfigurationBase", "ScriptedShowTestPlanConfigurationDialog");

	Params::InterchangePipelineConfigurationBase_ScriptedShowTestPlanConfigurationDialog Parms{};

	Parms.SourceData = SourceData;
	Parms.Translator = Translator;
	Parms.BaseNodeContainer = BaseNodeContainer;
	Parms.ReimportAsset = ReimportAsset;
	Parms.bSceneImport = bSceneImport;
	Parms.bReimport = bReimport;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (PipelineStacks != nullptr)
		*PipelineStacks = std::move(Parms.PipelineStacks);

	if (OutPipelines != nullptr)
		*OutPipelines = std::move(Parms.OutPipelines);

	return Parms.ReturnValue;
}


// Function InterchangeEngine.InterchangeEditorSettings.SetUsedGroupName
// (Final, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FName&                      InUsedGroupName                                        (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInterchangeEditorSettings::SetUsedGroupName(const class FName& InUsedGroupName)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeEditorSettings", "SetUsedGroupName");

	Params::InterchangeEditorSettings_SetUsedGroupName Parms{};

	Parms.InUsedGroupName = InUsedGroupName;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function InterchangeEngine.InterchangeEditorSettings.GetSelectableItems
// (Final, Native, Private, Const)
// Parameters:
// TArray<class FName>                     ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class FName> UInterchangeEditorSettings::GetSelectableItems() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeEditorSettings", "GetSelectableItems");

	Params::InterchangeEditorSettings_GetSelectableItems Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeEngine.InterchangeEditorSettings.GetUsedGroupName
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FName                       ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const class FName UInterchangeEditorSettings::GetUsedGroupName() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeEditorSettings", "GetUsedGroupName");

	Params::InterchangeEditorSettings_GetUsedGroupName Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeEngine.InterchangeAssetImportData.SetPipelines
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const TArray<class UObject*>&           InPipelines                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, NativeAccessSpecifierPublic)

void UInterchangeAssetImportData::SetPipelines(const TArray<class UObject*>& InPipelines)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeAssetImportData", "SetPipelines");

	Params::InterchangeAssetImportData_SetPipelines Parms{};

	Parms.InPipelines = std::move(InPipelines);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function InterchangeEngine.InterchangeAssetImportData.GetNodeContainer
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UInterchangeBaseNodeContainer*    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UInterchangeBaseNodeContainer* UInterchangeAssetImportData::GetNodeContainer() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeAssetImportData", "GetNodeContainer");

	Params::InterchangeAssetImportData_GetNodeContainer Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeEngine.InterchangeAssetImportData.GetNumberOfPipelines
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// int32                                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

int32 UInterchangeAssetImportData::GetNumberOfPipelines() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeAssetImportData", "GetNumberOfPipelines");

	Params::InterchangeAssetImportData_GetNumberOfPipelines Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeEngine.InterchangeAssetImportData.GetPipelines
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class UObject*>                  ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class UObject*> UInterchangeAssetImportData::GetPipelines() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeAssetImportData", "GetPipelines");

	Params::InterchangeAssetImportData_GetPipelines Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeEngine.InterchangeAssetImportData.GetStoredFactoryNode
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FString&                    InNodeUniqueId                                         (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UInterchangeFactoryBaseNode*      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UInterchangeFactoryBaseNode* UInterchangeAssetImportData::GetStoredFactoryNode(const class FString& InNodeUniqueId) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeAssetImportData", "GetStoredFactoryNode");

	Params::InterchangeAssetImportData_GetStoredFactoryNode Parms{};

	Parms.InNodeUniqueId = std::move(InNodeUniqueId);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeEngine.InterchangeAssetImportData.GetStoredNode
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class FString&                    InNodeUniqueId                                         (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UInterchangeBaseNode*       ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const class UInterchangeBaseNode* UInterchangeAssetImportData::GetStoredNode(const class FString& InNodeUniqueId) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeAssetImportData", "GetStoredNode");

	Params::InterchangeAssetImportData_GetStoredNode Parms{};

	Parms.InNodeUniqueId = std::move(InNodeUniqueId);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeEngine.InterchangeAssetImportData.GetTranslatorSettings
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UInterchangeTranslatorSettings*ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const class UInterchangeTranslatorSettings* UInterchangeAssetImportData::GetTranslatorSettings() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeAssetImportData", "GetTranslatorSettings");

	Params::InterchangeAssetImportData_GetTranslatorSettings Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeEngine.InterchangeAssetImportData.ScriptExtractDisplayLabels
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class FString>                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class FString> UInterchangeAssetImportData::ScriptExtractDisplayLabels() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeAssetImportData", "ScriptExtractDisplayLabels");

	Params::InterchangeAssetImportData_ScriptExtractDisplayLabels Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeEngine.InterchangeAssetImportData.ScriptExtractFilenames
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// TArray<class FString>                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class FString> UInterchangeAssetImportData::ScriptExtractFilenames() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeAssetImportData", "ScriptExtractFilenames");

	Params::InterchangeAssetImportData_ScriptExtractFilenames Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeEngine.InterchangeAssetImportData.ScriptGetFirstFilename
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class FString                           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class FString UInterchangeAssetImportData::ScriptGetFirstFilename() const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeAssetImportData", "ScriptGetFirstFilename");

	Params::InterchangeAssetImportData_ScriptGetFirstFilename Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeEngine.InterchangeAssetImportData.SetNodeContainer
// (Final, RequiredAPI, Native, Public, BlueprintCallable, Const)
// Parameters:
// class UInterchangeBaseNodeContainer*    InNodeContainer                                        (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInterchangeAssetImportData::SetNodeContainer(class UInterchangeBaseNodeContainer* InNodeContainer) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeAssetImportData", "SetNodeContainer");

	Params::InterchangeAssetImportData_SetNodeContainer Parms{};

	Parms.InNodeContainer = InNodeContainer;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function InterchangeEngine.InterchangeAssetImportData.SetTranslatorSettings
// (Final, RequiredAPI, Native, Public, BlueprintCallable, Const)
// Parameters:
// class UInterchangeTranslatorSettings*   TranslatorSettings                                     (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInterchangeAssetImportData::SetTranslatorSettings(class UInterchangeTranslatorSettings* TranslatorSettings) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeAssetImportData", "SetTranslatorSettings");

	Params::InterchangeAssetImportData_SetTranslatorSettings Parms{};

	Parms.TranslatorSettings = TranslatorSettings;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function InterchangeEngine.InterchangePipelineStackOverride.AddBlueprintPipeline
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// class UInterchangeBlueprintPipelineBase*PipelineBase                                           (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInterchangePipelineStackOverride::AddBlueprintPipeline(class UInterchangeBlueprintPipelineBase* PipelineBase)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangePipelineStackOverride", "AddBlueprintPipeline");

	Params::InterchangePipelineStackOverride_AddBlueprintPipeline Parms{};

	Parms.PipelineBase = PipelineBase;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function InterchangeEngine.InterchangePipelineStackOverride.AddPipeline
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// class UInterchangePipelineBase*         PipelineBase                                           (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInterchangePipelineStackOverride::AddPipeline(class UInterchangePipelineBase* PipelineBase)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangePipelineStackOverride", "AddPipeline");

	Params::InterchangePipelineStackOverride_AddPipeline Parms{};

	Parms.PipelineBase = PipelineBase;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function InterchangeEngine.InterchangePipelineStackOverride.AddPythonPipeline
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// class UInterchangePythonPipelineBase*   PipelineBase                                           (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInterchangePipelineStackOverride::AddPythonPipeline(class UInterchangePythonPipelineBase* PipelineBase)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangePipelineStackOverride", "AddPythonPipeline");

	Params::InterchangePipelineStackOverride_AddPythonPipeline Parms{};

	Parms.PipelineBase = PipelineBase;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function InterchangeEngine.InterchangeManager.CreateSourceData
// (Final, RequiredAPI, Native, Static, Public, BlueprintCallable)
// Parameters:
// const class FString&                    InFilename                                             (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UInterchangeSourceData*           ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UInterchangeSourceData* UInterchangeManager::CreateSourceData(const class FString& InFilename)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("InterchangeManager", "CreateSourceData");

	Params::InterchangeManager_CreateSourceData Parms{};

	Parms.InFilename = std::move(InFilename);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeEngine.InterchangeManager.GetInterchangeManagerScripted
// (Final, Native, Static, Public, BlueprintCallable)
// Parameters:
// class UInterchangeManager*              ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UInterchangeManager* UInterchangeManager::GetInterchangeManagerScripted()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = StaticClass()->GetFunction("InterchangeManager", "GetInterchangeManagerScripted");

	Params::InterchangeManager_GetInterchangeManagerScripted Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	GetDefaultObj()->ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeEngine.InterchangeManager.CancelAllTasks
// (Final, RequiredAPI, Native, Protected, BlueprintCallable)

void UInterchangeManager::CancelAllTasks()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeManager", "CancelAllTasks");

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, nullptr);

	Func->FunctionFlags = Flgs;
}


// Function InterchangeEngine.InterchangeManager.ExportAsset
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    Asset                                                  (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIsAutomated                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeManager::ExportAsset(const class UObject* Asset, bool bIsAutomated)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeManager", "ExportAsset");

	Params::InterchangeManager_ExportAsset Parms{};

	Parms.Asset = Asset;
	Parms.bIsAutomated = bIsAutomated;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeEngine.InterchangeManager.ExportScene
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// const class UObject*                    World                                                  (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bIsAutomated                                           (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeManager::ExportScene(const class UObject* World, bool bIsAutomated)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeManager", "ExportScene");

	Params::InterchangeManager_ExportScene Parms{};

	Parms.World = World;
	Parms.bIsAutomated = bIsAutomated;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeEngine.InterchangeManager.ImportAsset
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FString&                    ContentPath                                            (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UInterchangeSourceData*     SourceData                                             (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FImportAssetParameters&    ImportAssetParameters                                  (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// TArray<class UObject*>*                 OutImportedObjects                                     (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeManager::ImportAsset(const class FString& ContentPath, const class UInterchangeSourceData* SourceData, const struct FImportAssetParameters& ImportAssetParameters, TArray<class UObject*>* OutImportedObjects)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeManager", "ImportAsset");

	Params::InterchangeManager_ImportAsset Parms{};

	Parms.ContentPath = std::move(ContentPath);
	Parms.SourceData = SourceData;
	Parms.ImportAssetParameters = std::move(ImportAssetParameters);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutImportedObjects != nullptr)
		*OutImportedObjects = std::move(Parms.OutImportedObjects);

	return Parms.ReturnValue;
}


// Function InterchangeEngine.InterchangeManager.ImportScene
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FString&                    ContentPath                                            (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UInterchangeSourceData*     SourceData                                             (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FImportAssetParameters&    ImportAssetParameters                                  (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeManager::ImportScene(const class FString& ContentPath, const class UInterchangeSourceData* SourceData, const struct FImportAssetParameters& ImportAssetParameters)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeManager", "ImportScene");

	Params::InterchangeManager_ImportScene Parms{};

	Parms.ContentPath = std::move(ContentPath);
	Parms.SourceData = SourceData;
	Parms.ImportAssetParameters = std::move(ImportAssetParameters);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeEngine.InterchangeManager.IsInterchangeActive
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeManager::IsInterchangeActive()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeManager", "IsInterchangeActive");

	Params::InterchangeManager_IsInterchangeActive Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeEngine.InterchangeManager.ReimportAsset
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          ObjectToReimport                                       (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FImportAssetParameters&    ImportAssetParameters                                  (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// TArray<class UObject*>*                 OutImportedObjects                                     (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeManager::ReimportAsset(class UObject* ObjectToReimport, const struct FImportAssetParameters& ImportAssetParameters, TArray<class UObject*>* OutImportedObjects)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeManager", "ReimportAsset");

	Params::InterchangeManager_ReimportAsset Parms{};

	Parms.ObjectToReimport = ObjectToReimport;
	Parms.ImportAssetParameters = std::move(ImportAssetParameters);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutImportedObjects != nullptr)
		*OutImportedObjects = std::move(Parms.OutImportedObjects);

	return Parms.ReturnValue;
}


// Function InterchangeEngine.InterchangeManager.ScriptedImportAssetAsync
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FString&                    ContentPath                                            (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UInterchangeSourceData*     SourceData                                             (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FImportAssetParameters&    ImportAssetParameters                                  (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeManager::ScriptedImportAssetAsync(const class FString& ContentPath, const class UInterchangeSourceData* SourceData, const struct FImportAssetParameters& ImportAssetParameters)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeManager", "ScriptedImportAssetAsync");

	Params::InterchangeManager_ScriptedImportAssetAsync Parms{};

	Parms.ContentPath = std::move(ContentPath);
	Parms.SourceData = SourceData;
	Parms.ImportAssetParameters = std::move(ImportAssetParameters);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeEngine.InterchangeManager.ScriptedImportSceneAsync
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// const class FString&                    ContentPath                                            (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UInterchangeSourceData*     SourceData                                             (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FImportAssetParameters&    ImportAssetParameters                                  (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeManager::ScriptedImportSceneAsync(const class FString& ContentPath, const class UInterchangeSourceData* SourceData, const struct FImportAssetParameters& ImportAssetParameters)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeManager", "ScriptedImportSceneAsync");

	Params::InterchangeManager_ScriptedImportSceneAsync Parms{};

	Parms.ContentPath = std::move(ContentPath);
	Parms.SourceData = SourceData;
	Parms.ImportAssetParameters = std::move(ImportAssetParameters);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeEngine.InterchangeManager.ScriptedReimportAssetAsync
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable)
// Parameters:
// class UObject*                          ObjectToReimport                                       (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const struct FImportAssetParameters&    ImportAssetParameters                                  (ConstParm, Parm, OutParm, ReferenceParm, ContainsInstancedReference, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeManager::ScriptedReimportAssetAsync(class UObject* ObjectToReimport, const struct FImportAssetParameters& ImportAssetParameters)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeManager", "ScriptedReimportAssetAsync");

	Params::InterchangeManager_ScriptedReimportAssetAsync Parms{};

	Parms.ObjectToReimport = ObjectToReimport;
	Parms.ImportAssetParameters = std::move(ImportAssetParameters);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeEngine.InterchangeManager.WaitUntilAllTasksDone
// (Final, RequiredAPI, Native, Protected, BlueprintCallable)
// Parameters:
// bool                                    bCancel                                                (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

void UInterchangeManager::WaitUntilAllTasksDone(bool bCancel)
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeManager", "WaitUntilAllTasksDone");

	Params::InterchangeManager_WaitUntilAllTasksDone Parms{};

	Parms.bCancel = bCancel;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;
}


// Function InterchangeEngine.InterchangeManager.WarnIfInterchangeIsActive
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
// Parameters:
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeManager::WarnIfInterchangeIsActive()
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeManager", "WarnIfInterchangeIsActive");

	Params::InterchangeManager_WarnIfInterchangeIsActive Parms{};

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeEngine.InterchangeManager.CanReimport
// (Final, RequiredAPI, Native, Public, HasOutParams, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UObject*                    Object                                                 (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class FString>*                  OutFilenames                                           (Parm, OutParm, ZeroConstructor, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeManager::CanReimport(const class UObject* Object, TArray<class FString>* OutFilenames) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeManager", "CanReimport");

	Params::InterchangeManager_CanReimport Parms{};

	Parms.Object = Object;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	if (OutFilenames != nullptr)
		*OutFilenames = std::move(Parms.OutFilenames);

	return Parms.ReturnValue;
}


// Function InterchangeEngine.InterchangeManager.CanTranslateSourceData
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UInterchangeSourceData*     SourceData                                             (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bSceneImportOnly                                       (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeManager::CanTranslateSourceData(const class UInterchangeSourceData* SourceData, bool bSceneImportOnly) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeManager", "CanTranslateSourceData");

	Params::InterchangeManager_CanTranslateSourceData Parms{};

	Parms.SourceData = SourceData;
	Parms.bSceneImportOnly = bSceneImportOnly;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeEngine.InterchangeManager.GetAssetImportData
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UObject*                          Asset                                                  (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UInterchangeAssetImportData*      ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UInterchangeAssetImportData* UInterchangeManager::GetAssetImportData(class UObject* Asset) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeManager", "GetAssetImportData");

	Params::InterchangeManager_GetAssetImportData Parms{};

	Parms.Asset = Asset;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeEngine.InterchangeManager.GetRegisteredFactoryClass
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UClass*                     ClassToMake                                            (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UClass*                     ReturnValue                                            (ConstParm, Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

const class UClass* UInterchangeManager::GetRegisteredFactoryClass(const class UClass* ClassToMake) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeManager", "GetRegisteredFactoryClass");

	Params::InterchangeManager_GetRegisteredFactoryClass Parms{};

	Parms.ClassToMake = ClassToMake;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeEngine.InterchangeManager.GetSupportedAssetTypeFormats
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const EInterchangeTranslatorAssetType   ForTranslatorAssetType                                 (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const EInterchangeTranslatorType        ForTranslatorType                                      (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    bStrictMatchTranslatorType                             (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class FString>                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class FString> UInterchangeManager::GetSupportedAssetTypeFormats(const EInterchangeTranslatorAssetType ForTranslatorAssetType, const EInterchangeTranslatorType ForTranslatorType, bool bStrictMatchTranslatorType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeManager", "GetSupportedAssetTypeFormats");

	Params::InterchangeManager_GetSupportedAssetTypeFormats Parms{};

	Parms.ForTranslatorAssetType = ForTranslatorAssetType;
	Parms.ForTranslatorType = ForTranslatorType;
	Parms.bStrictMatchTranslatorType = bStrictMatchTranslatorType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeEngine.InterchangeManager.GetSupportedFormats
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const EInterchangeTranslatorType        ForTranslatorType                                      (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class FString>                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class FString> UInterchangeManager::GetSupportedFormats(const EInterchangeTranslatorType ForTranslatorType) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeManager", "GetSupportedFormats");

	Params::InterchangeManager_GetSupportedFormats Parms{};

	Parms.ForTranslatorType = ForTranslatorType;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeEngine.InterchangeManager.GetSupportedFormatsForObject
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UObject*                    Object                                                 (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// int32                                   SourceFileIndex                                        (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// TArray<class FString>                   ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NativeAccessSpecifierPublic)

TArray<class FString> UInterchangeManager::GetSupportedFormatsForObject(const class UObject* Object, int32 SourceFileIndex) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeManager", "GetSupportedFormatsForObject");

	Params::InterchangeManager_GetSupportedFormatsForObject Parms{};

	Parms.Object = Object;
	Parms.SourceFileIndex = SourceFileIndex;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeEngine.InterchangeManager.GetTranslatorForSourceData
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// const class UInterchangeSourceData*     SourceData                                             (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// class UInterchangeTranslatorBase*       ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

class UInterchangeTranslatorBase* UInterchangeManager::GetTranslatorForSourceData(const class UInterchangeSourceData* SourceData) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeManager", "GetTranslatorForSourceData");

	Params::InterchangeManager_GetTranslatorForSourceData Parms{};

	Parms.SourceData = SourceData;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeEngine.InterchangeManager.IsObjectBeingImported
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class UObject*                          Object                                                 (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeManager::IsObjectBeingImported(class UObject* Object) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeManager", "IsObjectBeingImported");

	Params::InterchangeManager_IsObjectBeingImported Parms{};

	Parms.Object = Object;

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


// Function InterchangeEngine.InterchangeMeshUtilities.ScriptedImportMorphTarget
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
// Parameters:
// class USkeletalMesh*                    SkeletalMesh                                           (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const int32                             LODIndex                                               (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class UInterchangeSourceData*     SourceData                                             (ConstParm, Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// const class FString&                    MorphTargetName                                        (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
// bool                                    ReturnValue                                            (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)

bool UInterchangeMeshUtilities::ScriptedImportMorphTarget(class USkeletalMesh* SkeletalMesh, const int32 LODIndex, const class UInterchangeSourceData* SourceData, const class FString& MorphTargetName) const
{
	static class UFunction* Func = nullptr;

	if (Func == nullptr)
		Func = Class->GetFunction("InterchangeMeshUtilities", "ScriptedImportMorphTarget");

	Params::InterchangeMeshUtilities_ScriptedImportMorphTarget Parms{};

	Parms.SkeletalMesh = SkeletalMesh;
	Parms.LODIndex = LODIndex;
	Parms.SourceData = SourceData;
	Parms.MorphTargetName = std::move(MorphTargetName);

	auto Flgs = Func->FunctionFlags;
	Func->FunctionFlags |= 0x400;

	UObject::ProcessEvent(Func, &Parms);

	Func->FunctionFlags = Flgs;

	return Parms.ReturnValue;
}


SDK_NAMESPACE_END
