#include "HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.h"

#include "Engine/GameInstance.h"
#include "HyperTwistTraining/HyperTwistTrainingCoachLibrary.h"
#include "HyperTwistTraining/HyperTwistTrainingSubsystem.h"

namespace HyperTwistTrainingRuntimeLibraryInternal
{
	UHyperTwistTrainingSubsystem* ResolveTrainingSubsystem(UObject* WorldContextObject)
	{
		if (WorldContextObject == nullptr)
		{
			return nullptr;
		}

		UWorld* World = WorldContextObject->GetWorld();
		if (World == nullptr)
		{
			return nullptr;
		}

		UGameInstance* GameInstance = World->GetGameInstance();
		return GameInstance != nullptr ? GameInstance->GetSubsystem<UHyperTwistTrainingSubsystem>() : nullptr;
	}

	FString ResolveCoachHandoffStartActionSourceLabel(
		const FHyperTwistTrainingCoachPanelState& PanelState,
		const EHyperTwistTrainingCoachHandoffKind HandoffKind,
		const FString& FallbackSourceLabel
	)
	{
		if (HandoffKind == EHyperTwistTrainingCoachHandoffKind::Queue
			&& !PanelState.PreferredQueueRecoveryActionSourceLabel.IsEmpty())
		{
			return PanelState.PreferredQueueRecoveryActionSourceLabel;
		}

		if (PanelState.PreferredCoachHandoffKind == HandoffKind
			&& !PanelState.PreferredCoachHandoffSourceLabel.IsEmpty())
		{
			return PanelState.PreferredCoachHandoffSourceLabel;
		}

		if ((HandoffKind == EHyperTwistTrainingCoachHandoffKind::FollowUp
				|| HandoffKind == EHyperTwistTrainingCoachHandoffKind::Recommended)
			&& !PanelState.PreferredGuidanceSourceLabel.IsEmpty())
		{
			return PanelState.PreferredGuidanceSourceLabel;
		}

		if (!PanelState.PreferredCoachHandoffSourceLabel.IsEmpty())
		{
			return PanelState.PreferredCoachHandoffSourceLabel;
		}

		if (HandoffKind == EHyperTwistTrainingCoachHandoffKind::Queue
			&& !PanelState.NextQueueSourceLabel.IsEmpty())
		{
			return PanelState.NextQueueSourceLabel;
		}

		if (!PanelState.PreferredLaunchBudgetSourceLabel.IsEmpty())
		{
			return PanelState.PreferredLaunchBudgetSourceLabel;
		}

		return FallbackSourceLabel;
	}

	FString ResolvePrimaryCoachActionStartActionSourceLabel(
		const FHyperTwistTrainingCoachPanelState& PanelState,
		const FString& FallbackSourceLabel
	)
	{
		if (PanelState.PreferredQueueRecoveryAction != EHyperTwistTrainingQueueRecoveryAction::None)
		{
			return ResolveCoachHandoffStartActionSourceLabel(
				PanelState,
				EHyperTwistTrainingCoachHandoffKind::Queue,
				FallbackSourceLabel
			);
		}

		if (PanelState.PreferredCoachHandoffKind != EHyperTwistTrainingCoachHandoffKind::None)
		{
			return ResolveCoachHandoffStartActionSourceLabel(
				PanelState,
				PanelState.PreferredCoachHandoffKind,
				FallbackSourceLabel
			);
		}

		if (!PanelState.PreferredGuidanceSourceLabel.IsEmpty())
		{
			return PanelState.PreferredGuidanceSourceLabel;
		}

		if (!PanelState.PreferredLaunchBudgetSourceLabel.IsEmpty())
		{
			return PanelState.PreferredLaunchBudgetSourceLabel;
		}

		return FallbackSourceLabel;
	}

	FString BuildCoachHandoffFallbackSourceLabel(const EHyperTwistTrainingCoachHandoffKind HandoffKind)
	{
		return FString::Printf(
			TEXT("coach-runtime-library-%s"),
			HandoffKind == EHyperTwistTrainingCoachHandoffKind::Queue
				? TEXT("queue")
				: (HandoffKind == EHyperTwistTrainingCoachHandoffKind::FollowUp
					? TEXT("follow-up")
					: (HandoffKind == EHyperTwistTrainingCoachHandoffKind::Recommended
						? TEXT("recommended")
						: TEXT("handoff")))
		);
	}
}

UHyperTwistTrainingSubsystem* UHyperTwistTrainingRuntimeLibrary::GetTrainingSubsystem(UObject* WorldContextObject)
{
	return HyperTwistTrainingRuntimeLibraryInternal::ResolveTrainingSubsystem(WorldContextObject);
}

bool UHyperTwistTrainingRuntimeLibrary::HasActiveTrainingRun(UObject* WorldContextObject)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->HasActiveRun();
	}

	return false;
}

bool UHyperTwistTrainingRuntimeLibrary::HasActiveMethodDrillRun(UObject* WorldContextObject)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->HasActiveMethodDrillRun();
	}

	return false;
}

FHyperTwistTrainingRunState UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingRunState(UObject* WorldContextObject)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->GetActiveRunState();
	}

	return FHyperTwistTrainingRunState();
}

bool UHyperTwistTrainingRuntimeLibrary::TryGetActiveImportedRuntimeSurface(
	UObject* WorldContextObject,
	FHyperTwistTrainingImportedRuntimeSurface& OutRuntimeSurface
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->TryGetActiveImportedRuntimeSurface(OutRuntimeSurface);
	}

	OutRuntimeSurface = FHyperTwistTrainingImportedRuntimeSurface();
	return false;
}

bool UHyperTwistTrainingRuntimeLibrary::TryGetActiveImportedRuntimeSelector(
	UObject* WorldContextObject,
	const FString& SelectorId,
	FHyperTwistTrainingImportedRuntimeSelector& OutSelector
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->TryGetActiveImportedRuntimeSelector(SelectorId, OutSelector);
	}

	OutSelector = FHyperTwistTrainingImportedRuntimeSelector();
	return false;
}

bool UHyperTwistTrainingRuntimeLibrary::TryGetActiveImportedRuntimeSelectorOptionCases(
	UObject* WorldContextObject,
	const FString& SelectorId,
	TArray<FHyperTwistTrainingCase>& OutCases
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->TryGetActiveImportedRuntimeSelectorOptionCases(SelectorId, OutCases);
	}

	OutCases.Reset();
	return false;
}

bool UHyperTwistTrainingRuntimeLibrary::TryGetActiveImportedRuntimeSelectionState(
	UObject* WorldContextObject,
	FHyperTwistTrainingImportedRuntimeSelectionState& OutSelectionState
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->TryGetActiveImportedRuntimeSelectionState(OutSelectionState);
	}

	OutSelectionState = FHyperTwistTrainingImportedRuntimeSelectionState();
	return false;
}

bool UHyperTwistTrainingRuntimeLibrary::TryGetActiveImportedGeneratedModeLaunchConfig(
	UObject* WorldContextObject,
	FHyperTwistTrainingImportedGeneratedModeLaunchConfig& OutLaunchConfig
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->TryGetActiveImportedGeneratedModeLaunchConfig(OutLaunchConfig);
	}

	OutLaunchConfig = FHyperTwistTrainingImportedGeneratedModeLaunchConfig();
	return false;
}

bool UHyperTwistTrainingRuntimeLibrary::TryGetActiveImportedGeneratedModeLaunchRequest(
	UObject* WorldContextObject,
	FHyperTwistTrainingImportedGeneratedModeLaunchRequest& OutLaunchRequest
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->TryGetActiveImportedGeneratedModeLaunchRequest(OutLaunchRequest);
	}

	OutLaunchRequest = FHyperTwistTrainingImportedGeneratedModeLaunchRequest();
	return false;
}

FHyperTwistTrainingImportedGeneratedModeLaunchRequest UHyperTwistTrainingRuntimeLibrary::CreateActiveImportedGeneratedModeLaunchRequest(
	UObject* WorldContextObject,
	const FString& RequestSource
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->CreateActiveImportedGeneratedModeLaunchRequest(RequestSource);
	}

	return FHyperTwistTrainingImportedGeneratedModeLaunchRequest();
}

bool UHyperTwistTrainingRuntimeLibrary::TryExecuteActiveImportedGeneratedModeLaunchRequest(
	UObject* WorldContextObject,
	FHyperTwistTrainingRunState& OutRunState,
	FString& OutBlockedReason
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->TryExecuteActiveImportedGeneratedModeLaunchRequest(
			OutRunState,
			OutBlockedReason
		);
	}

	OutRunState = FHyperTwistTrainingRunState();
	OutBlockedReason = TEXT("Training subsystem was unavailable.");
	return false;
}

FHyperTwistTrainingRunState UHyperTwistTrainingRuntimeLibrary::ApplyActiveImportedRuntimeSelectorOption(
	UObject* WorldContextObject,
	const FString& SelectorId,
	const FString& OptionId
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->ApplyActiveImportedRuntimeSelectorOption(SelectorId, OptionId);
	}

	return FHyperTwistTrainingRunState();
}

FHyperTwistTrainingRunState UHyperTwistTrainingRuntimeLibrary::ApplyActiveImportedGeneratedModeSelectorChoice(
	UObject* WorldContextObject,
	const FString& SelectorId,
	const FString& SelectedValue,
	const FString& DisplayValue
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->ApplyActiveImportedGeneratedModeSelectorChoice(
			SelectorId,
			SelectedValue,
			DisplayValue
		);
	}

	return FHyperTwistTrainingRunState();
}

FHyperTwistTrainingMethodDrillRunState UHyperTwistTrainingRuntimeLibrary::GetActiveMethodDrillRunState(
	UObject* WorldContextObject
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->GetActiveMethodDrillRunState();
	}

	return FHyperTwistTrainingMethodDrillRunState();
}

FHyperTwistTrainingSessionSummary UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingRunSummary(UObject* WorldContextObject)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->GetActiveRunSummary();
	}

	return FHyperTwistTrainingSessionSummary();
}

bool UHyperTwistTrainingRuntimeLibrary::HasActiveTrainingLiveTimer(UObject* WorldContextObject)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->HasActiveLiveTimer();
	}

	return false;
}

FHyperTwistTrainingLiveTimerState UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingLiveTimerState(
	UObject* WorldContextObject
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->GetActiveLiveTimerState();
	}

	return FHyperTwistTrainingLiveTimerState();
}

bool UHyperTwistTrainingRuntimeLibrary::OpenActiveRecognitionSession(
	UObject* WorldContextObject,
	FString& OutError
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->OpenActiveRecognitionSession(OutError);
	}

	OutError = TEXT("Training subsystem was unavailable.");
	return false;
}

FHyperTwistVisionPreviewResult UHyperTwistTrainingRuntimeLibrary::SubmitActiveRecognitionFrame(
	UObject* WorldContextObject,
	const FHyperTwistVisionFrameEnvelope& Frame
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->SubmitActiveRecognitionFrame(Frame);
	}

	return FHyperTwistVisionPreviewResult();
}

FHyperTwistVisionCommitResult UHyperTwistTrainingRuntimeLibrary::CommitActiveRecognitionObservation(
	UObject* WorldContextObject,
	const FHyperTwistVisionCommitRequest& Request
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->CommitActiveRecognitionObservation(Request);
	}

	return FHyperTwistVisionCommitResult();
}

FHyperTwistVisionFinalizeResult UHyperTwistTrainingRuntimeLibrary::FinalizeActiveRecognitionSession(
	UObject* WorldContextObject
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->FinalizeActiveRecognitionSession();
	}

	return FHyperTwistVisionFinalizeResult();
}

bool UHyperTwistTrainingRuntimeLibrary::CloseActiveRecognitionSession(
	UObject* WorldContextObject,
	FString& OutError
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->CloseActiveRecognitionSession(OutError);
	}

	OutError = TEXT("Training subsystem was unavailable.");
	return false;
}

FHyperTwistTrainingMethodDrillSummary UHyperTwistTrainingRuntimeLibrary::GetActiveMethodDrillSummary(
	UObject* WorldContextObject
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->GetActiveMethodDrillSummary();
	}

	return FHyperTwistTrainingMethodDrillSummary();
}

FHyperTwistTrainingMethodDrillDiagnosticPacket
UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingMethodDrillDiagnosticPacket(UObject* WorldContextObject)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->GetActiveMethodDrillDiagnosticPacket();
	}

	return FHyperTwistTrainingMethodDrillDiagnosticPacket();
}

FHyperTwistTrainingSessionTemplate
UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingMethodDrillFollowUpTemplate(UObject* WorldContextObject)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->GetActiveMethodDrillFollowUpTemplate();
	}

	return FHyperTwistTrainingSessionTemplate();
}

FHyperTwistTrainingRepositoryState UHyperTwistTrainingRuntimeLibrary::GetTrainingRepositoryState(UObject* WorldContextObject)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->GetTrainingRepositoryState();
	}

	return FHyperTwistTrainingRepositoryState();
}

FHyperTwistTrainingKnowledgeReferenceBundle
UHyperTwistTrainingRuntimeLibrary::GetBundledHypercubingKnowledgeReferenceBundle()
{
	return UHyperTwistTrainingKnowledgeLibrary::MakeHypercubingKnowledgeReferenceBundle();
}

FHyperTwistTrainingViewerReferenceBundle UHyperTwistTrainingRuntimeLibrary::GetBundledBrowserViewerReferenceBundle()
{
	return UHyperTwistTrainingViewerLibrary::BuildBundledBrowserViewerReferenceBundle();
}

FHyperTwistTrainingCompanionReferenceBundle
UHyperTwistTrainingRuntimeLibrary::GetBundledEmbodiedCompanionReferenceBundle()
{
	return UHyperTwistTrainingCompanionLibrary::BuildBundledEmbodiedCompanionReferenceBundle();
}

FHyperTwistTrainingSpatialReferenceBundle
UHyperTwistTrainingRuntimeLibrary::GetBundledBrowserSpatialReferenceBundle()
{
	return UHyperTwistTrainingSpatialLibrary::BuildBundledBrowserSpatialReferenceBundle();
}

FHyperTwistTrainingClassicCubingReferenceBundle
UHyperTwistTrainingRuntimeLibrary::GetBundledClassicCubingReferenceBundle()
{
	return UHyperTwistTrainingClassicCubingLibrary::BuildBundledClassicCubingReferenceBundle();
}

FHyperTwistTrainingLegacy4DReferenceBundle UHyperTwistTrainingRuntimeLibrary::GetBundledLegacy4DReferenceBundle()
{
	return UHyperTwistTrainingLegacy4DLibrary::BuildBundledLegacy4DReferenceBundle();
}

FHyperTwistTrainingSharedAssetReferenceBundle UHyperTwistTrainingRuntimeLibrary::GetBundledSharedAssetReferenceBundle()
{
	return UHyperTwistTrainingSharedAssetLibrary::BuildBundledSharedAssetReferenceBundle();
}

FHyperTwistTrainingControlPlaneReferenceBundle UHyperTwistTrainingRuntimeLibrary::GetBundledControlPlaneReferenceBundle()
{
	return UHyperTwistTrainingControlPlaneLibrary::BuildBundledControlPlaneReferenceBundle();
}

bool UHyperTwistTrainingRuntimeLibrary::TryGetLatestGeneratedModeLaunchRequestForDeck(
	UObject* WorldContextObject,
	const FString& UserId,
	const FString& DeckId,
	FHyperTwistTrainingImportedGeneratedModeLaunchRequest& OutLaunchRequest
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->TryGetLatestGeneratedModeLaunchRequestForDeck(
			UserId,
			DeckId,
			OutLaunchRequest
		);
	}

	OutLaunchRequest = FHyperTwistTrainingImportedGeneratedModeLaunchRequest();
	return false;
}

bool UHyperTwistTrainingRuntimeLibrary::TryGetLatestGeneratedModeLaunchRequestForActiveDeck(
	UObject* WorldContextObject,
	FHyperTwistTrainingImportedGeneratedModeLaunchRequest& OutLaunchRequest
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->TryGetLatestGeneratedModeLaunchRequestForActiveDeck(OutLaunchRequest);
	}

	OutLaunchRequest = FHyperTwistTrainingImportedGeneratedModeLaunchRequest();
	return false;
}

FHyperTwistTrainingRepositoryIntegrityReport UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingRepositoryIntegrityReport(
	UObject* WorldContextObject
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->GetActiveRepositoryIntegrityReport();
	}

	return FHyperTwistTrainingRepositoryIntegrityReport();
}

FHyperTwistTrainingRepositoryRoundTripVerification
UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingRepositoryRoundTripVerification(
	UObject* WorldContextObject
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->GetActiveRepositoryRoundTripVerification();
	}

	return FHyperTwistTrainingRepositoryRoundTripVerification();
}

FHyperTwistTrainingCoachPanelState UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachPanelState(
	UObject* WorldContextObject
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->GetActiveCoachPanelState();
	}

	return FHyperTwistTrainingCoachPanelState();
}

FHyperTwistTrainingDeckHistorySummary UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingDeckHistorySummary(UObject* WorldContextObject)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->GetActiveDeckHistorySummary();
	}

	return FHyperTwistTrainingDeckHistorySummary();
}

FHyperTwistTrainingTimingTrendSummary UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingTimingTrendSummary(UObject* WorldContextObject)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->GetActiveTimingTrendSummary();
	}

	return FHyperTwistTrainingTimingTrendSummary();
}

FHyperTwistTrainingPersonalBestSummary UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingPersonalBestSummary(UObject* WorldContextObject)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->GetActivePersonalBestSummary();
	}

	return FHyperTwistTrainingPersonalBestSummary();
}

FHyperTwistTrainingDeckScopedStats UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingDeckScopedStats(UObject* WorldContextObject)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->GetActiveDeckScopedStats();
	}

	return FHyperTwistTrainingDeckScopedStats();
}

FHyperTwistTrainingCaseScopedStats UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCurrentCaseScopedStats(UObject* WorldContextObject)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->GetActiveCurrentCaseScopedStats();
	}

	return FHyperTwistTrainingCaseScopedStats();
}

FHyperTwistTrainingAnalyticsReportBundle UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingAnalyticsReportBundle(
	UObject* WorldContextObject
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return UHyperTwistTrainingAnalyticsLibrary::BuildActiveTrainingAnalyticsReportBundle(
			TrainingSubsystem->GetActiveRunSummary(),
			TrainingSubsystem->GetActiveDeckHistorySummary(),
			TrainingSubsystem->GetActiveTimingTrendSummary(),
			TrainingSubsystem->GetActivePersonalBestSummary(),
			TrainingSubsystem->GetActiveDeckScopedStats(),
			TrainingSubsystem->GetActiveCurrentCaseScopedStats(),
			TrainingSubsystem->GetActiveLiveTimerState(),
			TrainingSubsystem->GetActiveReplayReviewAnalytics(),
			TrainingSubsystem->GetActiveRecognitionReplaySummary()
		);
	}

	return FHyperTwistTrainingAnalyticsReportBundle();
}

bool UHyperTwistTrainingRuntimeLibrary::TryGetActiveTrainingAnalyticsReport(
	UObject* WorldContextObject,
	const FString& ReportId,
	FHyperTwistTrainingAnalyticsReportDefinition& OutReport
)
{
	const FHyperTwistTrainingAnalyticsReportBundle Bundle = GetActiveTrainingAnalyticsReportBundle(
		WorldContextObject
	);
	return UHyperTwistTrainingAnalyticsLibrary::TryGetReportById(Bundle, ReportId, OutReport);
}

FString UHyperTwistTrainingRuntimeLibrary::BuildActiveTrainingAnalyticsReportDataView(
	UObject* WorldContextObject,
	const FString& ReportId
)
{
	FHyperTwistTrainingAnalyticsReportDefinition Report;
	if (TryGetActiveTrainingAnalyticsReport(WorldContextObject, ReportId, Report))
	{
		return UHyperTwistTrainingAnalyticsLibrary::BuildReportDataViewTsv(Report);
	}

	return TEXT("");
}

bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledBrowserViewerEmbedContract(
	const FString& ContractId,
	FHyperTwistTrainingViewerEmbedContract& OutContract
)
{
	return UHyperTwistTrainingViewerLibrary::TryGetEmbedContractById(
		GetBundledBrowserViewerReferenceBundle(),
		ContractId,
		OutContract
	);
}

bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledBrowserViewerQaCheck(
	const FString& CheckId,
	FHyperTwistTrainingViewerQaCheck& OutCheck
)
{
	return UHyperTwistTrainingViewerLibrary::TryGetQaCheckById(
		GetBundledBrowserViewerReferenceBundle(),
		CheckId,
		OutCheck
	);
}

FString UHyperTwistTrainingRuntimeLibrary::BuildBundledBrowserViewerQaChecklistTsv()
{
	return UHyperTwistTrainingViewerLibrary::BuildQaChecklistTsv(GetBundledBrowserViewerReferenceBundle());
}

bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledEmbodiedCompanionNarrationContract(
	const FString& ContractId,
	FHyperTwistTrainingCompanionNarrationContract& OutContract
)
{
	return UHyperTwistTrainingCompanionLibrary::TryGetNarrationContractById(
		GetBundledEmbodiedCompanionReferenceBundle(),
		ContractId,
		OutContract
	);
}

bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledEmbodiedCompanionAvatarEmbedContract(
	const FString& ContractId,
	FHyperTwistTrainingCompanionAvatarEmbedContract& OutContract
)
{
	return UHyperTwistTrainingCompanionLibrary::TryGetAvatarEmbedContractById(
		GetBundledEmbodiedCompanionReferenceBundle(),
		ContractId,
		OutContract
	);
}

bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledEmbodiedCompanionVendorAdapterBoundary(
	const FString& BoundaryId,
	FHyperTwistTrainingCompanionVendorAdapterBoundary& OutBoundary
)
{
	return UHyperTwistTrainingCompanionLibrary::TryGetVendorAdapterBoundaryById(
		GetBundledEmbodiedCompanionReferenceBundle(),
		BoundaryId,
		OutBoundary
	);
}

FString UHyperTwistTrainingRuntimeLibrary::BuildBundledEmbodiedCompanionSubtitleCueChecklistTsv()
{
	return UHyperTwistTrainingCompanionLibrary::BuildSubtitleCueChecklistTsv(
		GetBundledEmbodiedCompanionReferenceBundle()
	);
}

bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledBrowserSpatialSceneContract(
	const FString& ContractId,
	FHyperTwistTrainingSpatialSceneContract& OutContract
)
{
	return UHyperTwistTrainingSpatialLibrary::TryGetSceneContractById(
		GetBundledBrowserSpatialReferenceBundle(),
		ContractId,
		OutContract
	);
}

bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledBrowserSpatialXrSessionContract(
	const FString& ContractId,
	FHyperTwistTrainingSpatialXrSessionContract& OutContract
)
{
	return UHyperTwistTrainingSpatialLibrary::TryGetXrSessionContractById(
		GetBundledBrowserSpatialReferenceBundle(),
		ContractId,
		OutContract
	);
}

bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledBrowserSpatialUiContract(
	const FString& ContractId,
	FHyperTwistTrainingSpatialUiContract& OutContract
)
{
	return UHyperTwistTrainingSpatialLibrary::TryGetSpatialUiContractById(
		GetBundledBrowserSpatialReferenceBundle(),
		ContractId,
		OutContract
	);
}

bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledBrowserSpatialEffectBoundary(
	const FString& BoundaryId,
	FHyperTwistTrainingSpatialEffectBoundary& OutBoundary
)
{
	return UHyperTwistTrainingSpatialLibrary::TryGetEffectBoundaryById(
		GetBundledBrowserSpatialReferenceBundle(),
		BoundaryId,
		OutBoundary
	);
}

bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledBrowserSpatialStateMotionContract(
	const FString& ContractId,
	FHyperTwistTrainingSpatialStateMotionContract& OutContract
)
{
	return UHyperTwistTrainingSpatialLibrary::TryGetStateMotionContractById(
		GetBundledBrowserSpatialReferenceBundle(),
		ContractId,
		OutContract
	);
}

FString UHyperTwistTrainingRuntimeLibrary::BuildBundledBrowserSpatialPackageChecklistTsv()
{
	return UHyperTwistTrainingSpatialLibrary::BuildPackageChecklistTsv(
		GetBundledBrowserSpatialReferenceBundle()
	);
}

bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledClassicCubingSemanticContract(
	const FString& ContractId,
	FHyperTwistTrainingClassicCubingSemanticContract& OutContract
)
{
	return UHyperTwistTrainingClassicCubingLibrary::TryGetSemanticContractById(
		GetBundledClassicCubingReferenceBundle(),
		ContractId,
		OutContract
	);
}

bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledClassicCubingGeometryContract(
	const FString& ContractId,
	FHyperTwistTrainingClassicCubingGeometryContract& OutContract
)
{
	return UHyperTwistTrainingClassicCubingLibrary::TryGetGeometryContractById(
		GetBundledClassicCubingReferenceBundle(),
		ContractId,
		OutContract
	);
}

bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledClassicCubingViewerAdapterContract(
	const FString& ContractId,
	FHyperTwistTrainingClassicCubingViewerAdapterContract& OutContract
)
{
	return UHyperTwistTrainingClassicCubingLibrary::TryGetViewerAdapterContractById(
		GetBundledClassicCubingReferenceBundle(),
		ContractId,
		OutContract
	);
}

bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledClassicCubingDeviceAdapterBoundary(
	const FString& BoundaryId,
	FHyperTwistTrainingClassicCubingDeviceAdapterBoundary& OutBoundary
)
{
	return UHyperTwistTrainingClassicCubingLibrary::TryGetDeviceAdapterBoundaryById(
		GetBundledClassicCubingReferenceBundle(),
		BoundaryId,
		OutBoundary
	);
}

bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledClassicCubingSearchContract(
	const FString& ContractId,
	FHyperTwistTrainingClassicCubingSearchContract& OutContract
)
{
	return UHyperTwistTrainingClassicCubingLibrary::TryGetSearchContractById(
		GetBundledClassicCubingReferenceBundle(),
		ContractId,
		OutContract
	);
}

bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledClassicCubingComplianceBoundary(
	const FString& BoundaryId,
	FHyperTwistTrainingClassicCubingComplianceBoundary& OutBoundary
)
{
	return UHyperTwistTrainingClassicCubingLibrary::TryGetComplianceBoundaryById(
		GetBundledClassicCubingReferenceBundle(),
		BoundaryId,
		OutBoundary
	);
}

FString UHyperTwistTrainingRuntimeLibrary::BuildBundledClassicCubingPackageChecklistTsv()
{
	return UHyperTwistTrainingClassicCubingLibrary::BuildPackageChecklistTsv(
		GetBundledClassicCubingReferenceBundle()
	);
}

bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledLegacy4DHistoryContract(
	const FString& ContractId,
	FHyperTwistTrainingLegacy4DHistoryContract& OutContract
)
{
	return UHyperTwistTrainingLegacy4DLibrary::TryGetHistoryContractById(
		GetBundledLegacy4DReferenceBundle(),
		ContractId,
		OutContract
	);
}

bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledLegacy4DMacroContract(
	const FString& ContractId,
	FHyperTwistTrainingLegacy4DMacroContract& OutContract
)
{
	return UHyperTwistTrainingLegacy4DLibrary::TryGetMacroContractById(
		GetBundledLegacy4DReferenceBundle(),
		ContractId,
		OutContract
	);
}

bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledLegacy4DPuzzleDescriptionContract(
	const FString& ContractId,
	FHyperTwistTrainingLegacy4DPuzzleDescriptionContract& OutContract
)
{
	return UHyperTwistTrainingLegacy4DLibrary::TryGetPuzzleDescriptionContractById(
		GetBundledLegacy4DReferenceBundle(),
		ContractId,
		OutContract
	);
}

bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledLegacy4DInteractionContract(
	const FString& ContractId,
	FHyperTwistTrainingLegacy4DInteractionContract& OutContract
)
{
	return UHyperTwistTrainingLegacy4DLibrary::TryGetInteractionContractById(
		GetBundledLegacy4DReferenceBundle(),
		ContractId,
		OutContract
	);
}

bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledLegacy4DAttributionBoundary(
	const FString& BoundaryId,
	FHyperTwistTrainingLegacy4DAttributionBoundary& OutBoundary
)
{
	return UHyperTwistTrainingLegacy4DLibrary::TryGetAttributionBoundaryById(
		GetBundledLegacy4DReferenceBundle(),
		BoundaryId,
		OutBoundary
	);
}

FString UHyperTwistTrainingRuntimeLibrary::BuildBundledLegacy4DPackageChecklistTsv()
{
	return UHyperTwistTrainingLegacy4DLibrary::BuildPackageChecklistTsv(
		GetBundledLegacy4DReferenceBundle()
	);
}

bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledSharedAssetFixtureReference(
	const FString& FixtureId,
	FHyperTwistTrainingSharedAssetFixtureReference& OutReference
)
{
	return UHyperTwistTrainingSharedAssetLibrary::TryGetFixtureReferenceById(
		GetBundledSharedAssetReferenceBundle(),
		FixtureId,
		OutReference
	);
}

bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledSharedAssetQaPackContract(
	const FString& ContractId,
	FHyperTwistTrainingSharedAssetQaPackContract& OutContract
)
{
	return UHyperTwistTrainingSharedAssetLibrary::TryGetQaPackContractById(
		GetBundledSharedAssetReferenceBundle(),
		ContractId,
		OutContract
	);
}

bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledSharedAssetProvenanceBoundary(
	const FString& BoundaryId,
	FHyperTwistTrainingSharedAssetProvenanceBoundary& OutBoundary
)
{
	return UHyperTwistTrainingSharedAssetLibrary::TryGetProvenanceBoundaryById(
		GetBundledSharedAssetReferenceBundle(),
		BoundaryId,
		OutBoundary
	);
}

bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledSharedAssetRefreshPattern(
	const FString& PatternId,
	FHyperTwistTrainingSharedAssetRefreshPattern& OutPattern
)
{
	return UHyperTwistTrainingSharedAssetLibrary::TryGetRefreshPatternById(
		GetBundledSharedAssetReferenceBundle(),
		PatternId,
		OutPattern
	);
}

FString UHyperTwistTrainingRuntimeLibrary::BuildBundledSharedAssetFixtureChecklistTsv()
{
	return UHyperTwistTrainingSharedAssetLibrary::BuildFixtureChecklistTsv(
		GetBundledSharedAssetReferenceBundle()
	);
}

bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledControlPlanePackageReference(
	const FString& PackageId,
	FHyperTwistTrainingControlPlanePackageReference& OutReference
)
{
	return UHyperTwistTrainingControlPlaneLibrary::TryGetPackageReferenceById(
		GetBundledControlPlaneReferenceBundle(),
		PackageId,
		OutReference
	);
}

bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledControlPlaneReplayDiagnosticContract(
	const FString& ContractId,
	FHyperTwistTrainingReplayDiagnosticContract& OutContract
)
{
	return UHyperTwistTrainingControlPlaneLibrary::TryGetReplayDiagnosticContractById(
		GetBundledControlPlaneReferenceBundle(),
		ContractId,
		OutContract
	);
}

bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledControlPlaneFeatureGovernanceContract(
	const FString& ContractId,
	FHyperTwistTrainingFeatureGovernanceContract& OutContract
)
{
	return UHyperTwistTrainingControlPlaneLibrary::TryGetFeatureGovernanceContractById(
		GetBundledControlPlaneReferenceBundle(),
		ContractId,
		OutContract
	);
}

bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledControlPlaneScheduledChangeContract(
	const FString& ContractId,
	FHyperTwistTrainingScheduledChangeContract& OutContract
)
{
	return UHyperTwistTrainingControlPlaneLibrary::TryGetScheduledChangeContractById(
		GetBundledControlPlaneReferenceBundle(),
		ContractId,
		OutContract
	);
}

bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledControlPlaneEarlyAccessRolloutContract(
	const FString& ContractId,
	FHyperTwistTrainingEarlyAccessRolloutContract& OutContract
)
{
	return UHyperTwistTrainingControlPlaneLibrary::TryGetEarlyAccessRolloutContractById(
		GetBundledControlPlaneReferenceBundle(),
		ContractId,
		OutContract
	);
}

bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledControlPlaneComplianceBoundary(
	const FString& BoundaryId,
	FHyperTwistTrainingControlPlaneComplianceBoundary& OutBoundary
)
{
	return UHyperTwistTrainingControlPlaneLibrary::TryGetComplianceBoundaryById(
		GetBundledControlPlaneReferenceBundle(),
		BoundaryId,
		OutBoundary
	);
}

FString UHyperTwistTrainingRuntimeLibrary::BuildBundledControlPlanePackageChecklistTsv()
{
	return UHyperTwistTrainingControlPlaneLibrary::BuildPackageChecklistTsv(
		GetBundledControlPlaneReferenceBundle()
	);
}

FHyperTwistTrainingLearnerDeckStateSummary UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingLearnerDeckStateSummary(UObject* WorldContextObject)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->GetActiveLearnerDeckStateSummary();
	}

	return FHyperTwistTrainingLearnerDeckStateSummary();
}

FHyperTwistTrainingLearnerProfile UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingLearnerProfile(UObject* WorldContextObject)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->GetActiveLearnerProfile();
	}

	return FHyperTwistTrainingLearnerProfile();
}

FHyperTwistTrainingCoachMemorySnapshot UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachMemorySnapshot(UObject* WorldContextObject)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->GetActiveCoachMemorySnapshot();
	}

	return FHyperTwistTrainingCoachMemorySnapshot();
}

FHyperTwistReplayReviewAnalytics UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingReplayReviewAnalytics(
	UObject* WorldContextObject
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->GetActiveReplayReviewAnalytics();
	}

	return FHyperTwistReplayReviewAnalytics();
}

FHyperTwistRecognitionReplaySummary UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingRecognitionReplaySummary(
	UObject* WorldContextObject
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->GetActiveRecognitionReplaySummary();
	}

	return FHyperTwistRecognitionReplaySummary();
}

FHyperTwistTrainingRecognitionSessionState
UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingRecognitionSessionState(UObject* WorldContextObject)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->GetActiveRecognitionSessionState();
	}

	return FHyperTwistTrainingRecognitionSessionState();
}

TArray<FHyperTwistCoachSignal> UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachSignals(
	UObject* WorldContextObject
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->GetActiveCoachSignals();
	}

	return TArray<FHyperTwistCoachSignal>();
}

FHyperTwistCoachBrief UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachBrief(UObject* WorldContextObject)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->GetActiveCoachBrief();
	}

	return FHyperTwistCoachBrief();
}

FHyperTwistTrainingCoachActionPlan UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachActionPlan(
	UObject* WorldContextObject
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->GetActiveCoachActionPlan();
	}

	return FHyperTwistTrainingCoachActionPlan();
}

FHyperTwistTrainingCoachActionPlanSummary UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachActionPlanSummary(
	UObject* WorldContextObject
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->GetActiveCoachActionPlanSummary();
	}

	return FHyperTwistTrainingCoachActionPlanSummary();
}

FHyperTwistTrainingCoachActionPlanOutcomeSummary UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachActionPlanOutcomeSummary(
	UObject* WorldContextObject
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->GetActiveCoachActionPlanOutcomeSummary();
	}

	return FHyperTwistTrainingCoachActionPlanOutcomeSummary();
}

FHyperTwistTrainingCoachActionSequenceSummary UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachActionSequenceSummary(
	UObject* WorldContextObject
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->GetActiveCoachActionSequenceSummary();
	}

	return FHyperTwistTrainingCoachActionSequenceSummary();
}

FHyperTwistTrainingCoachActionClosureSummary UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachActionClosureSummary(
	UObject* WorldContextObject
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->GetActiveCoachActionClosureSummary();
	}

	return FHyperTwistTrainingCoachActionClosureSummary();
}

FHyperTwistTrainingCoachClosureMemorySummary UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachClosureMemorySummary(
	UObject* WorldContextObject
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->GetActiveCoachClosureMemorySummary();
	}

	return FHyperTwistTrainingCoachClosureMemorySummary();
}

FHyperTwistTrainingCoachRecommendationHistorySummary UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachRecommendationHistorySummary(
	UObject* WorldContextObject
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->GetActiveCoachRecommendationHistorySummary();
	}

	return FHyperTwistTrainingCoachRecommendationHistorySummary();
}

FHyperTwistTrainingCoachCarryForwardPolicySummary UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachCarryForwardPolicySummary(
	UObject* WorldContextObject
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->GetActiveCoachCarryForwardPolicySummary();
	}

	return FHyperTwistTrainingCoachCarryForwardPolicySummary();
}

FHyperTwistTrainingCoachArchivePolicySummary UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachArchivePolicySummary(
	UObject* WorldContextObject
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->GetActiveCoachArchivePolicySummary();
	}

	return FHyperTwistTrainingCoachArchivePolicySummary();
}

FHyperTwistCoachBrief UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachFollowUpBrief(UObject* WorldContextObject)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->GetActiveCoachFollowUpBrief();
	}

	return FHyperTwistCoachBrief();
}

FHyperTwistCoachSessionQueueSummary UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachSessionQueueSummary(
	UObject* WorldContextObject)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->GetActiveCoachSessionQueueSummary();
	}

	return FHyperTwistCoachSessionQueueSummary();
}

FHyperTwistTrainingCoachSessionQueueState UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachSessionQueueState(
	UObject* WorldContextObject
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->GetActiveCoachSessionQueueState();
	}

	return FHyperTwistTrainingCoachSessionQueueState();
}

FHyperTwistCoachScheduleHorizonSummary UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachScheduleHorizonSummary(
	UObject* WorldContextObject
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->GetActiveCoachScheduleHorizonSummary();
	}

	return FHyperTwistCoachScheduleHorizonSummary();
}

FHyperTwistCoachSchedulePolicySummary UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachSchedulePolicySummary(
	UObject* WorldContextObject
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->GetActiveCoachSchedulePolicySummary();
	}

	return FHyperTwistCoachSchedulePolicySummary();
}

FHyperTwistTrainingCoachSessionQueueExecutionSummary UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachSessionQueueExecutionSummary(
	UObject* WorldContextObject
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->GetActiveCoachSessionQueueExecutionSummary();
	}

	return FHyperTwistTrainingCoachSessionQueueExecutionSummary();
}

FString UHyperTwistTrainingRuntimeLibrary::ResolveActiveTrainingCoachHandoffStartActionSourceLabel(
	UObject* WorldContextObject,
	const EHyperTwistTrainingCoachHandoffKind HandoffKind
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return HyperTwistTrainingRuntimeLibraryInternal::ResolveCoachHandoffStartActionSourceLabel(
			TrainingSubsystem->GetActiveCoachPanelState(),
			HandoffKind,
			HyperTwistTrainingRuntimeLibraryInternal::BuildCoachHandoffFallbackSourceLabel(HandoffKind)
		);
	}

	return HyperTwistTrainingRuntimeLibraryInternal::BuildCoachHandoffFallbackSourceLabel(HandoffKind);
}

FString UHyperTwistTrainingRuntimeLibrary::ResolveActiveTrainingPrimaryCoachActionStartActionSourceLabel(
	UObject* WorldContextObject
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return HyperTwistTrainingRuntimeLibraryInternal::ResolvePrimaryCoachActionStartActionSourceLabel(
			TrainingSubsystem->GetActiveCoachPanelState(),
			TEXT("coach-runtime-library-primary-action")
		);
	}

	return TEXT("coach-runtime-library-primary-action");
}

FHyperTwistTrainingCoachPrimaryActionSurface
UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachPrimaryActionSurface(
	UObject* WorldContextObject
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		FHyperTwistTrainingCoachPrimaryActionSurface Surface =
			UHyperTwistTrainingCoachLibrary::DerivePrimaryCoachActionSurface(
				TrainingSubsystem->GetActiveCoachPanelState()
			);
		Surface.ActionSourceLabel = Surface.bCanExecute
			? ResolveActiveTrainingPrimaryCoachActionStartActionSourceLabel(WorldContextObject)
			: FString();
		return Surface;
	}

	return FHyperTwistTrainingCoachPrimaryActionSurface();
}

FHyperTwistTrainingCoachQueueControlSurface
UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachQueueControlSurface(
	UObject* WorldContextObject
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		FHyperTwistTrainingCoachQueueControlSurface Surface =
			UHyperTwistTrainingCoachLibrary::DeriveCoachQueueControlSurface(
				TrainingSubsystem->GetActiveCoachSessionQueueState(),
				TrainingSubsystem->GetActiveCoachPanelState()
			);
		Surface.PromoteActionSourceLabel = Surface.bCanPromote
			? ResolveActiveTrainingCoachHandoffStartActionSourceLabel(
				WorldContextObject,
				EHyperTwistTrainingCoachHandoffKind::Queue
			)
			: FString();
		return Surface;
	}

	return FHyperTwistTrainingCoachQueueControlSurface();
}

FHyperTwistTrainingCoachQueueRecoveryPostureSurface
UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachQueueRecoveryPostureSurface(
	UObject* WorldContextObject
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		const FHyperTwistTrainingCoachPanelState PanelState =
			TrainingSubsystem->GetActiveCoachPanelState();
		const FHyperTwistTrainingCoachPrimaryActionSurface PrimaryActionSurface =
			GetActiveTrainingCoachPrimaryActionSurface(WorldContextObject);
		const FHyperTwistTrainingCoachQueueControlSurface QueueControlSurface =
			GetActiveTrainingCoachQueueControlSurface(WorldContextObject);
		return UHyperTwistTrainingCoachLibrary::DeriveCoachQueueRecoveryPostureSurface(
			TrainingSubsystem->GetActiveCoachSchedulePolicySummary(),
			TrainingSubsystem->GetActiveCoachSessionQueueExecutionSummary(),
			PanelState,
			PrimaryActionSurface,
			QueueControlSurface
		);
	}

	return FHyperTwistTrainingCoachQueueRecoveryPostureSurface();
}

FHyperTwistTrainingCoachHandoffContinuationSurface
UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachHandoffContinuationSurface(
	UObject* WorldContextObject
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		const FHyperTwistTrainingCoachPanelState PanelState =
			TrainingSubsystem->GetActiveCoachPanelState();
		const FHyperTwistTrainingCoachPrimaryActionSurface PrimaryActionSurface =
			GetActiveTrainingCoachPrimaryActionSurface(WorldContextObject);
		const FHyperTwistTrainingCoachQueueControlSurface QueueControlSurface =
			GetActiveTrainingCoachQueueControlSurface(WorldContextObject);
		const FHyperTwistTrainingCoachQueueRecoveryPostureSurface QueueRecoveryPostureSurface =
			UHyperTwistTrainingCoachLibrary::DeriveCoachQueueRecoveryPostureSurface(
				TrainingSubsystem->GetActiveCoachSchedulePolicySummary(),
				TrainingSubsystem->GetActiveCoachSessionQueueExecutionSummary(),
				PanelState,
				PrimaryActionSurface,
				QueueControlSurface
			);
		return UHyperTwistTrainingCoachLibrary::DeriveCoachHandoffContinuationSurface(
			PanelState,
			PrimaryActionSurface,
			QueueControlSurface,
			QueueRecoveryPostureSurface
		);
	}

	return FHyperTwistTrainingCoachHandoffContinuationSurface();
}

FHyperTwistTrainingCoachFocusProvenanceSurface
UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachFocusProvenanceSurface(
	UObject* WorldContextObject
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		const FHyperTwistTrainingCoachPanelState PanelState =
			TrainingSubsystem->GetActiveCoachPanelState();
		const FHyperTwistTrainingCoachPrimaryActionSurface PrimaryActionSurface =
			GetActiveTrainingCoachPrimaryActionSurface(WorldContextObject);
		const FHyperTwistTrainingCoachQueueControlSurface QueueControlSurface =
			GetActiveTrainingCoachQueueControlSurface(WorldContextObject);
		const FHyperTwistTrainingCoachQueueRecoveryPostureSurface QueueRecoveryPostureSurface =
			UHyperTwistTrainingCoachLibrary::DeriveCoachQueueRecoveryPostureSurface(
				TrainingSubsystem->GetActiveCoachSchedulePolicySummary(),
				TrainingSubsystem->GetActiveCoachSessionQueueExecutionSummary(),
				PanelState,
				PrimaryActionSurface,
				QueueControlSurface
			);
		const FHyperTwistTrainingCoachHandoffContinuationSurface HandoffContinuationSurface =
			UHyperTwistTrainingCoachLibrary::DeriveCoachHandoffContinuationSurface(
				PanelState,
				PrimaryActionSurface,
				QueueControlSurface,
				QueueRecoveryPostureSurface
			);
		return UHyperTwistTrainingCoachLibrary::DeriveCoachFocusProvenanceSurface(
			PanelState,
			PrimaryActionSurface,
			QueueControlSurface,
			QueueRecoveryPostureSurface,
			HandoffContinuationSurface
		);
	}

	return FHyperTwistTrainingCoachFocusProvenanceSurface();
}

FHyperTwistTrainingCoachWorkloadBudgetSurface
UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachWorkloadBudgetSurface(
	UObject* WorldContextObject
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		const FHyperTwistTrainingCoachPanelState PanelState =
			TrainingSubsystem->GetActiveCoachPanelState();
		const FHyperTwistTrainingCoachPrimaryActionSurface PrimaryActionSurface =
			GetActiveTrainingCoachPrimaryActionSurface(WorldContextObject);
		const FHyperTwistTrainingCoachQueueControlSurface QueueControlSurface =
			GetActiveTrainingCoachQueueControlSurface(WorldContextObject);
		const FHyperTwistTrainingCoachQueueRecoveryPostureSurface QueueRecoveryPostureSurface =
			UHyperTwistTrainingCoachLibrary::DeriveCoachQueueRecoveryPostureSurface(
				TrainingSubsystem->GetActiveCoachSchedulePolicySummary(),
				TrainingSubsystem->GetActiveCoachSessionQueueExecutionSummary(),
				PanelState,
				PrimaryActionSurface,
				QueueControlSurface
			);
		const FHyperTwistTrainingCoachHandoffContinuationSurface HandoffContinuationSurface =
			UHyperTwistTrainingCoachLibrary::DeriveCoachHandoffContinuationSurface(
				PanelState,
				PrimaryActionSurface,
				QueueControlSurface,
				QueueRecoveryPostureSurface
			);
		const FHyperTwistTrainingCoachFocusProvenanceSurface FocusProvenanceSurface =
			UHyperTwistTrainingCoachLibrary::DeriveCoachFocusProvenanceSurface(
				PanelState,
				PrimaryActionSurface,
				QueueControlSurface,
				QueueRecoveryPostureSurface,
				HandoffContinuationSurface
			);
		return UHyperTwistTrainingCoachLibrary::DeriveCoachWorkloadBudgetSurface(
			PanelState,
			QueueRecoveryPostureSurface,
			HandoffContinuationSurface,
			FocusProvenanceSurface
		);
	}

	return FHyperTwistTrainingCoachWorkloadBudgetSurface();
}

FHyperTwistTrainingCoachReadinessEligibilitySurface
UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachReadinessEligibilitySurface(
	UObject* WorldContextObject
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		const FHyperTwistTrainingCoachPanelState PanelState =
			TrainingSubsystem->GetActiveCoachPanelState();
		const FHyperTwistTrainingCoachPrimaryActionSurface PrimaryActionSurface =
			GetActiveTrainingCoachPrimaryActionSurface(WorldContextObject);
		const FHyperTwistTrainingCoachQueueControlSurface QueueControlSurface =
			GetActiveTrainingCoachQueueControlSurface(WorldContextObject);
		const FHyperTwistTrainingCoachQueueRecoveryPostureSurface QueueRecoveryPostureSurface =
			UHyperTwistTrainingCoachLibrary::DeriveCoachQueueRecoveryPostureSurface(
				TrainingSubsystem->GetActiveCoachSchedulePolicySummary(),
				TrainingSubsystem->GetActiveCoachSessionQueueExecutionSummary(),
				PanelState,
				PrimaryActionSurface,
				QueueControlSurface
			);
		const FHyperTwistTrainingCoachHandoffContinuationSurface HandoffContinuationSurface =
			UHyperTwistTrainingCoachLibrary::DeriveCoachHandoffContinuationSurface(
				PanelState,
				PrimaryActionSurface,
				QueueControlSurface,
				QueueRecoveryPostureSurface
			);
		const FHyperTwistTrainingCoachFocusProvenanceSurface FocusProvenanceSurface =
			UHyperTwistTrainingCoachLibrary::DeriveCoachFocusProvenanceSurface(
				PanelState,
				PrimaryActionSurface,
				QueueControlSurface,
				QueueRecoveryPostureSurface,
				HandoffContinuationSurface
			);
		const FHyperTwistTrainingCoachWorkloadBudgetSurface WorkloadBudgetSurface =
			UHyperTwistTrainingCoachLibrary::DeriveCoachWorkloadBudgetSurface(
				PanelState,
				QueueRecoveryPostureSurface,
				HandoffContinuationSurface,
				FocusProvenanceSurface
			);
		return UHyperTwistTrainingCoachLibrary::DeriveCoachReadinessEligibilitySurface(
			PanelState,
			PrimaryActionSurface,
			QueueControlSurface,
			QueueRecoveryPostureSurface,
			HandoffContinuationSurface,
			FocusProvenanceSurface,
			WorkloadBudgetSurface
		);
	}

	return FHyperTwistTrainingCoachReadinessEligibilitySurface();
}

FHyperTwistTrainingCoachVerificationRecognitionReviewContextSurface
UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachVerificationRecognitionReviewContextSurface(
	UObject* WorldContextObject
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		const FHyperTwistTrainingCoachPanelState PanelState =
			TrainingSubsystem->GetActiveCoachPanelState();
		const FHyperTwistTrainingCoachPrimaryActionSurface PrimaryActionSurface =
			GetActiveTrainingCoachPrimaryActionSurface(WorldContextObject);
		const FHyperTwistTrainingCoachQueueControlSurface QueueControlSurface =
			GetActiveTrainingCoachQueueControlSurface(WorldContextObject);
		const FHyperTwistTrainingCoachQueueRecoveryPostureSurface QueueRecoveryPostureSurface =
			UHyperTwistTrainingCoachLibrary::DeriveCoachQueueRecoveryPostureSurface(
				TrainingSubsystem->GetActiveCoachSchedulePolicySummary(),
				TrainingSubsystem->GetActiveCoachSessionQueueExecutionSummary(),
				PanelState,
				PrimaryActionSurface,
				QueueControlSurface
			);
		const FHyperTwistTrainingCoachHandoffContinuationSurface HandoffContinuationSurface =
			UHyperTwistTrainingCoachLibrary::DeriveCoachHandoffContinuationSurface(
				PanelState,
				PrimaryActionSurface,
				QueueControlSurface,
				QueueRecoveryPostureSurface
			);
		const FHyperTwistTrainingCoachFocusProvenanceSurface FocusProvenanceSurface =
			UHyperTwistTrainingCoachLibrary::DeriveCoachFocusProvenanceSurface(
				PanelState,
				PrimaryActionSurface,
				QueueControlSurface,
				QueueRecoveryPostureSurface,
				HandoffContinuationSurface
			);
		const FHyperTwistTrainingCoachWorkloadBudgetSurface WorkloadBudgetSurface =
			UHyperTwistTrainingCoachLibrary::DeriveCoachWorkloadBudgetSurface(
				PanelState,
				QueueRecoveryPostureSurface,
				HandoffContinuationSurface,
				FocusProvenanceSurface
			);
		const FHyperTwistTrainingCoachReadinessEligibilitySurface ReadinessEligibilitySurface =
			UHyperTwistTrainingCoachLibrary::DeriveCoachReadinessEligibilitySurface(
				PanelState,
				PrimaryActionSurface,
				QueueControlSurface,
				QueueRecoveryPostureSurface,
				HandoffContinuationSurface,
				FocusProvenanceSurface,
				WorkloadBudgetSurface
			);
		return UHyperTwistTrainingCoachLibrary::
			DeriveCoachVerificationRecognitionReviewContextSurface(
				PanelState,
				FocusProvenanceSurface,
				WorkloadBudgetSurface,
				ReadinessEligibilitySurface
			);
	}

	return FHyperTwistTrainingCoachVerificationRecognitionReviewContextSurface();
}

FHyperTwistTrainingCoachGeneratedModeLaunchExecutionContextSurface
UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachGeneratedModeLaunchExecutionContextSurface(
	UObject* WorldContextObject
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		const FHyperTwistTrainingCoachPanelState PanelState =
			TrainingSubsystem->GetActiveCoachPanelState();
		const FHyperTwistTrainingCoachReadinessEligibilitySurface ReadinessEligibilitySurface =
			GetActiveTrainingCoachReadinessEligibilitySurface(WorldContextObject);
		const FHyperTwistTrainingCoachVerificationRecognitionReviewContextSurface
			VerificationRecognitionReviewContextSurface =
				GetActiveTrainingCoachVerificationRecognitionReviewContextSurface(
					WorldContextObject
				);
		return UHyperTwistTrainingCoachLibrary::DeriveCoachGeneratedModeLaunchExecutionContextSurface(
			PanelState,
			ReadinessEligibilitySurface,
			VerificationRecognitionReviewContextSurface
		);
	}

	return FHyperTwistTrainingCoachGeneratedModeLaunchExecutionContextSurface();
}

FHyperTwistTrainingCoachGeneratedModeSelectorApplicationContextSurface
UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachGeneratedModeSelectorApplicationContextSurface(
	UObject* WorldContextObject
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		const FHyperTwistTrainingRunState RunState = TrainingSubsystem->GetActiveRunState();

		FHyperTwistTrainingImportedRuntimeSelectionState ImportedRuntimeSelectionState;
		TrainingSubsystem->TryGetActiveImportedRuntimeSelectionState(ImportedRuntimeSelectionState);

		FHyperTwistTrainingImportedGeneratedModeLaunchConfig LaunchConfig;
		TrainingSubsystem->TryGetActiveImportedGeneratedModeLaunchConfig(LaunchConfig);

		const FHyperTwistTrainingCoachGeneratedModeLaunchExecutionContextSurface
			LaunchExecutionContextSurface =
				GetActiveTrainingCoachGeneratedModeLaunchExecutionContextSurface(
					WorldContextObject
				);
		return UHyperTwistTrainingCoachLibrary::DeriveCoachGeneratedModeSelectorApplicationContextSurface(
			RunState.ActiveDeck,
			ImportedRuntimeSelectionState,
			LaunchConfig,
			LaunchExecutionContextSurface
		);
	}

	return FHyperTwistTrainingCoachGeneratedModeSelectorApplicationContextSurface();
}

FHyperTwistTrainingCoachGeneratedModeSelectorRosterSurface
UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachGeneratedModeSelectorRosterSurface(
	UObject* WorldContextObject
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		const FHyperTwistTrainingRunState RunState = TrainingSubsystem->GetActiveRunState();

		FHyperTwistTrainingImportedRuntimeSelectionState ImportedRuntimeSelectionState;
		TrainingSubsystem->TryGetActiveImportedRuntimeSelectionState(ImportedRuntimeSelectionState);

		const FHyperTwistTrainingCoachGeneratedModeSelectorApplicationContextSurface
			SelectorApplicationContextSurface =
				GetActiveTrainingCoachGeneratedModeSelectorApplicationContextSurface(
					WorldContextObject
				);
		return UHyperTwistTrainingCoachLibrary::DeriveCoachGeneratedModeSelectorRosterSurface(
			RunState.ActiveDeck,
			ImportedRuntimeSelectionState,
			SelectorApplicationContextSurface
		);
	}

	return FHyperTwistTrainingCoachGeneratedModeSelectorRosterSurface();
}

FHyperTwistTrainingCoachGeneratedModeSelectorOptionMenuSurface
UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachGeneratedModeSelectorOptionMenuSurface(
	UObject* WorldContextObject,
	const FString& SelectorId
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		const FHyperTwistTrainingRunState RunState = TrainingSubsystem->GetActiveRunState();

		FHyperTwistTrainingImportedRuntimeSelectionState ImportedRuntimeSelectionState;
		TrainingSubsystem->TryGetActiveImportedRuntimeSelectionState(ImportedRuntimeSelectionState);

		const FHyperTwistTrainingCoachGeneratedModeSelectorRosterSurface SelectorRosterSurface =
			GetActiveTrainingCoachGeneratedModeSelectorRosterSurface(WorldContextObject);
		return UHyperTwistTrainingCoachLibrary::DeriveCoachGeneratedModeSelectorOptionMenuSurface(
			RunState.ActiveDeck,
			ImportedRuntimeSelectionState,
			SelectorId,
			SelectorRosterSurface
		);
	}

	return FHyperTwistTrainingCoachGeneratedModeSelectorOptionMenuSurface();
}

FHyperTwistTrainingCoachGeneratedModeSelectorOptionActionabilitySurface
UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachGeneratedModeSelectorOptionActionabilitySurface(
	UObject* WorldContextObject,
	const FString& SelectorId
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		const FHyperTwistTrainingRunState RunState = TrainingSubsystem->GetActiveRunState();
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionMenuSurface OptionMenuSurface =
			GetActiveTrainingCoachGeneratedModeSelectorOptionMenuSurface(
				WorldContextObject,
				SelectorId
			);
		return UHyperTwistTrainingCoachLibrary::DeriveCoachGeneratedModeSelectorOptionActionabilitySurface(
			RunState.ActiveDeck,
			SelectorId,
			OptionMenuSurface
		);
	}

	return FHyperTwistTrainingCoachGeneratedModeSelectorOptionActionabilitySurface();
}

FHyperTwistTrainingCoachGeneratedModeSelectorOptionDispatchSurface
UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachGeneratedModeSelectorOptionDispatchSurface(
	UObject* WorldContextObject,
	const FString& SelectorId
)
{
	if (GetTrainingSubsystem(WorldContextObject) != nullptr)
	{
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionMenuSurface OptionMenuSurface =
			GetActiveTrainingCoachGeneratedModeSelectorOptionMenuSurface(
				WorldContextObject,
				SelectorId
			);
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionActionabilitySurface
			OptionActionabilitySurface =
				GetActiveTrainingCoachGeneratedModeSelectorOptionActionabilitySurface(
					WorldContextObject,
					SelectorId
				);
		return UHyperTwistTrainingCoachLibrary::DeriveCoachGeneratedModeSelectorOptionDispatchSurface(
			SelectorId,
			OptionMenuSurface,
			OptionActionabilitySurface
		);
	}

	return FHyperTwistTrainingCoachGeneratedModeSelectorOptionDispatchSurface();
}

FHyperTwistTrainingCoachGeneratedModeSelectorOptionExecutionImpactSurface
UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachGeneratedModeSelectorOptionExecutionImpactSurface(
	UObject* WorldContextObject,
	const FString& SelectorId
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		const FHyperTwistTrainingRunState RunState = TrainingSubsystem->GetActiveRunState();
		const FHyperTwistTrainingCoachGeneratedModeLaunchExecutionContextSurface
			LaunchExecutionContextSurface =
				GetActiveTrainingCoachGeneratedModeLaunchExecutionContextSurface(
					WorldContextObject
				);
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionMenuSurface OptionMenuSurface =
			GetActiveTrainingCoachGeneratedModeSelectorOptionMenuSurface(
				WorldContextObject,
				SelectorId
			);
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionDispatchSurface
			OptionDispatchSurface =
				GetActiveTrainingCoachGeneratedModeSelectorOptionDispatchSurface(
					WorldContextObject,
					SelectorId
				);
		return UHyperTwistTrainingCoachLibrary::DeriveCoachGeneratedModeSelectorOptionExecutionImpactSurface(
			RunState,
			SelectorId,
			LaunchExecutionContextSurface,
			OptionMenuSurface,
			OptionDispatchSurface
		);
	}

	return FHyperTwistTrainingCoachGeneratedModeSelectorOptionExecutionImpactSurface();
}

FHyperTwistTrainingCoachGeneratedModeSelectorOptionRequestAlignmentSurface
UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachGeneratedModeSelectorOptionRequestAlignmentSurface(
	UObject* WorldContextObject,
	const FString& SelectorId
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		const FHyperTwistTrainingRunState RunState = TrainingSubsystem->GetActiveRunState();
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionMenuSurface OptionMenuSurface =
			GetActiveTrainingCoachGeneratedModeSelectorOptionMenuSurface(
				WorldContextObject,
				SelectorId
			);
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionDispatchSurface
			OptionDispatchSurface =
				GetActiveTrainingCoachGeneratedModeSelectorOptionDispatchSurface(
					WorldContextObject,
					SelectorId
				);
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionExecutionImpactSurface
			OptionExecutionImpactSurface =
				GetActiveTrainingCoachGeneratedModeSelectorOptionExecutionImpactSurface(
					WorldContextObject,
					SelectorId
				);
		return UHyperTwistTrainingCoachLibrary::DeriveCoachGeneratedModeSelectorOptionRequestAlignmentSurface(
			RunState,
			SelectorId,
			OptionMenuSurface,
			OptionDispatchSurface,
			OptionExecutionImpactSurface
		);
	}

	return FHyperTwistTrainingCoachGeneratedModeSelectorOptionRequestAlignmentSurface();
}

FHyperTwistTrainingCoachGeneratedModeSelectorOptionStoredRequestDeltaSurface
UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachGeneratedModeSelectorOptionStoredRequestDeltaSurface(
	UObject* WorldContextObject,
	const FString& SelectorId
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		const FHyperTwistTrainingRunState RunState = TrainingSubsystem->GetActiveRunState();
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionMenuSurface OptionMenuSurface =
			GetActiveTrainingCoachGeneratedModeSelectorOptionMenuSurface(
				WorldContextObject,
				SelectorId
			);
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionDispatchSurface
			OptionDispatchSurface =
				GetActiveTrainingCoachGeneratedModeSelectorOptionDispatchSurface(
					WorldContextObject,
					SelectorId
				);
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionRequestAlignmentSurface
			OptionRequestAlignmentSurface =
				GetActiveTrainingCoachGeneratedModeSelectorOptionRequestAlignmentSurface(
					WorldContextObject,
					SelectorId
				);
		return UHyperTwistTrainingCoachLibrary::DeriveCoachGeneratedModeSelectorOptionStoredRequestDeltaSurface(
			RunState,
			SelectorId,
			OptionMenuSurface,
			OptionDispatchSurface,
			OptionRequestAlignmentSurface
		);
	}

	return FHyperTwistTrainingCoachGeneratedModeSelectorOptionStoredRequestDeltaSurface();
}

FHyperTwistTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface
UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface(
	UObject* WorldContextObject,
	const FString& SelectorId
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		const FHyperTwistTrainingRunState RunState = TrainingSubsystem->GetActiveRunState();
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionMenuSurface OptionMenuSurface =
			GetActiveTrainingCoachGeneratedModeSelectorOptionMenuSurface(
				WorldContextObject,
				SelectorId
			);
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionDispatchSurface
			OptionDispatchSurface =
				GetActiveTrainingCoachGeneratedModeSelectorOptionDispatchSurface(
					WorldContextObject,
					SelectorId
				);
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionRequestAlignmentSurface
			OptionRequestAlignmentSurface =
				GetActiveTrainingCoachGeneratedModeSelectorOptionRequestAlignmentSurface(
					WorldContextObject,
					SelectorId
				);
		return UHyperTwistTrainingCoachLibrary::DeriveCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface(
			RunState,
			SelectorId,
			OptionMenuSurface,
			OptionDispatchSurface,
			OptionRequestAlignmentSurface
		);
	}

	return FHyperTwistTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface();
}

FHyperTwistTrainingCoachGeneratedModeSelectorOptionLaunchRequestMetadataPreviewSurface
UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachGeneratedModeSelectorOptionLaunchRequestMetadataPreviewSurface(
	UObject* WorldContextObject,
	const FString& SelectorId
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		const FHyperTwistTrainingRunState RunState = TrainingSubsystem->GetActiveRunState();
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionMenuSurface OptionMenuSurface =
			GetActiveTrainingCoachGeneratedModeSelectorOptionMenuSurface(
				WorldContextObject,
				SelectorId
			);
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface
			OptionLaunchRequestPreviewSurface =
				GetActiveTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface(
					WorldContextObject,
					SelectorId
				);
		return UHyperTwistTrainingCoachLibrary::
			DeriveCoachGeneratedModeSelectorOptionLaunchRequestMetadataPreviewSurface(
				RunState,
				SelectorId,
				OptionMenuSurface,
				OptionLaunchRequestPreviewSurface
			);
	}

	return FHyperTwistTrainingCoachGeneratedModeSelectorOptionLaunchRequestMetadataPreviewSurface();
}

FHyperTwistTrainingCoachGeneratedModeSelectorOptionLaunchRequestEnvelopePreviewSurface
UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachGeneratedModeSelectorOptionLaunchRequestEnvelopePreviewSurface(
	UObject* WorldContextObject,
	const FString& SelectorId
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		const FHyperTwistTrainingRunState RunState = TrainingSubsystem->GetActiveRunState();
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionMenuSurface OptionMenuSurface =
			GetActiveTrainingCoachGeneratedModeSelectorOptionMenuSurface(
				WorldContextObject,
				SelectorId
			);
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface
			OptionLaunchRequestPreviewSurface =
				GetActiveTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface(
					WorldContextObject,
					SelectorId
				);
		return UHyperTwistTrainingCoachLibrary::
			DeriveCoachGeneratedModeSelectorOptionLaunchRequestEnvelopePreviewSurface(
				RunState,
				SelectorId,
				OptionMenuSurface,
				OptionLaunchRequestPreviewSurface
			);
	}

	return FHyperTwistTrainingCoachGeneratedModeSelectorOptionLaunchRequestEnvelopePreviewSurface();
}

FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionCasePreviewSurface
UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachGeneratedModeSelectorOptionOwnedExecutionCasePreviewSurface(
	UObject* WorldContextObject,
	const FString& SelectorId
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		const FHyperTwistTrainingRunState RunState = TrainingSubsystem->GetActiveRunState();
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionMenuSurface OptionMenuSurface =
			GetActiveTrainingCoachGeneratedModeSelectorOptionMenuSurface(
				WorldContextObject,
				SelectorId
			);
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionLaunchRequestEnvelopePreviewSurface
			OptionLaunchRequestEnvelopePreviewSurface =
				GetActiveTrainingCoachGeneratedModeSelectorOptionLaunchRequestEnvelopePreviewSurface(
					WorldContextObject,
					SelectorId
				);
		return UHyperTwistTrainingCoachLibrary::
			DeriveCoachGeneratedModeSelectorOptionOwnedExecutionCasePreviewSurface(
				RunState,
				SelectorId,
				OptionMenuSurface,
				OptionLaunchRequestEnvelopePreviewSurface
			);
	}

	return FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionCasePreviewSurface();
}

FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionPromptPreviewSurface
UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachGeneratedModeSelectorOptionOwnedExecutionPromptPreviewSurface(
	UObject* WorldContextObject,
	const FString& SelectorId
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		const FHyperTwistTrainingRunState RunState = TrainingSubsystem->GetActiveRunState();
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionMenuSurface OptionMenuSurface =
			GetActiveTrainingCoachGeneratedModeSelectorOptionMenuSurface(
				WorldContextObject,
				SelectorId
			);
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface
			OptionLaunchRequestPreviewSurface =
				GetActiveTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface(
					WorldContextObject,
					SelectorId
				);
		return UHyperTwistTrainingCoachLibrary::
			DeriveCoachGeneratedModeSelectorOptionOwnedExecutionPromptPreviewSurface(
				RunState,
				SelectorId,
				OptionMenuSurface,
				OptionLaunchRequestPreviewSurface
			);
	}

	return FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionPromptPreviewSurface();
}

FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionDeliveryPreviewSurface
UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachGeneratedModeSelectorOptionOwnedExecutionDeliveryPreviewSurface(
	UObject* WorldContextObject,
	const FString& SelectorId
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		const FHyperTwistTrainingRunState RunState = TrainingSubsystem->GetActiveRunState();
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionMenuSurface OptionMenuSurface =
			GetActiveTrainingCoachGeneratedModeSelectorOptionMenuSurface(
				WorldContextObject,
				SelectorId
			);
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface
			OptionLaunchRequestPreviewSurface =
				GetActiveTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface(
					WorldContextObject,
					SelectorId
				);
		return UHyperTwistTrainingCoachLibrary::
			DeriveCoachGeneratedModeSelectorOptionOwnedExecutionDeliveryPreviewSurface(
				RunState,
				SelectorId,
				OptionMenuSurface,
				OptionLaunchRequestPreviewSurface
			);
	}

	return FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionDeliveryPreviewSurface();
}

FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionPuzzleSubsetDifficultyPreviewSurface
UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachGeneratedModeSelectorOptionOwnedExecutionPuzzleSubsetDifficultyPreviewSurface(
	UObject* WorldContextObject,
	const FString& SelectorId
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		const FHyperTwistTrainingRunState RunState = TrainingSubsystem->GetActiveRunState();
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionMenuSurface OptionMenuSurface =
			GetActiveTrainingCoachGeneratedModeSelectorOptionMenuSurface(
				WorldContextObject,
				SelectorId
			);
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface
			OptionLaunchRequestPreviewSurface =
				GetActiveTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface(
					WorldContextObject,
					SelectorId
				);
		return UHyperTwistTrainingCoachLibrary::
			DeriveCoachGeneratedModeSelectorOptionOwnedExecutionPuzzleSubsetDifficultyPreviewSurface(
				RunState,
				SelectorId,
				OptionMenuSurface,
				OptionLaunchRequestPreviewSurface
			);
	}

	return FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionPuzzleSubsetDifficultyPreviewSurface();
}

FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionProvenancePreviewSurface
UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachGeneratedModeSelectorOptionOwnedExecutionProvenancePreviewSurface(
	UObject* WorldContextObject,
	const FString& SelectorId
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		const FHyperTwistTrainingRunState RunState = TrainingSubsystem->GetActiveRunState();
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionMenuSurface OptionMenuSurface =
			GetActiveTrainingCoachGeneratedModeSelectorOptionMenuSurface(
				WorldContextObject,
				SelectorId
			);
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface
			OptionLaunchRequestPreviewSurface =
				GetActiveTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface(
					WorldContextObject,
					SelectorId
				);
		return UHyperTwistTrainingCoachLibrary::
			DeriveCoachGeneratedModeSelectorOptionOwnedExecutionProvenancePreviewSurface(
				RunState,
				SelectorId,
				OptionMenuSurface,
				OptionLaunchRequestPreviewSurface
			);
	}

	return FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionProvenancePreviewSurface();
}

FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionDeckTitleSelectionPolicyPreviewSurface
UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachGeneratedModeSelectorOptionOwnedExecutionDeckTitleSelectionPolicyPreviewSurface(
	UObject* WorldContextObject,
	const FString& SelectorId
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		const FHyperTwistTrainingRunState RunState = TrainingSubsystem->GetActiveRunState();
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionMenuSurface OptionMenuSurface =
			GetActiveTrainingCoachGeneratedModeSelectorOptionMenuSurface(
				WorldContextObject,
				SelectorId
			);
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface
			OptionLaunchRequestPreviewSurface =
				GetActiveTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface(
					WorldContextObject,
					SelectorId
				);
		return UHyperTwistTrainingCoachLibrary::
			DeriveCoachGeneratedModeSelectorOptionOwnedExecutionDeckTitleSelectionPolicyPreviewSurface(
				RunState,
				SelectorId,
				OptionMenuSurface,
				OptionLaunchRequestPreviewSurface
			);
	}

	return FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionDeckTitleSelectionPolicyPreviewSurface();
}

FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionDeckIdRuntimeSurfaceRetentionPreviewSurface
UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachGeneratedModeSelectorOptionOwnedExecutionDeckIdRuntimeSurfaceRetentionPreviewSurface(
	UObject* WorldContextObject,
	const FString& SelectorId
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		const FHyperTwistTrainingRunState RunState = TrainingSubsystem->GetActiveRunState();
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionMenuSurface OptionMenuSurface =
			GetActiveTrainingCoachGeneratedModeSelectorOptionMenuSurface(
				WorldContextObject,
				SelectorId
			);
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface
			OptionLaunchRequestPreviewSurface =
				GetActiveTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface(
					WorldContextObject,
					SelectorId
				);
		return UHyperTwistTrainingCoachLibrary::
			DeriveCoachGeneratedModeSelectorOptionOwnedExecutionDeckIdRuntimeSurfaceRetentionPreviewSurface(
				RunState,
				SelectorId,
				OptionMenuSurface,
				OptionLaunchRequestPreviewSurface
			);
	}

	return FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionDeckIdRuntimeSurfaceRetentionPreviewSurface();
}

FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionDeliveryModeRosterAllowedModeRetentionPreviewSurface
UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachGeneratedModeSelectorOptionOwnedExecutionDeliveryModeRosterAllowedModeRetentionPreviewSurface(
	UObject* WorldContextObject,
	const FString& SelectorId
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		const FHyperTwistTrainingRunState RunState = TrainingSubsystem->GetActiveRunState();
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionMenuSurface OptionMenuSurface =
			GetActiveTrainingCoachGeneratedModeSelectorOptionMenuSurface(
				WorldContextObject,
				SelectorId
			);
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface
			OptionLaunchRequestPreviewSurface =
				GetActiveTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface(
					WorldContextObject,
					SelectorId
				);
		return UHyperTwistTrainingCoachLibrary::
			DeriveCoachGeneratedModeSelectorOptionOwnedExecutionDeliveryModeRosterAllowedModeRetentionPreviewSurface(
				RunState,
				SelectorId,
				OptionMenuSurface,
				OptionLaunchRequestPreviewSurface
			);
	}

	return FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionDeliveryModeRosterAllowedModeRetentionPreviewSurface();
}

FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionRealScrambleVirtualCubeSmartCubeCapabilityRetentionPreviewSurface
UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachGeneratedModeSelectorOptionOwnedExecutionRealScrambleVirtualCubeSmartCubeCapabilityRetentionPreviewSurface(
	UObject* WorldContextObject,
	const FString& SelectorId
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		const FHyperTwistTrainingRunState RunState = TrainingSubsystem->GetActiveRunState();
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionMenuSurface OptionMenuSurface =
			GetActiveTrainingCoachGeneratedModeSelectorOptionMenuSurface(
				WorldContextObject,
				SelectorId
			);
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface
			OptionLaunchRequestPreviewSurface =
				GetActiveTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface(
					WorldContextObject,
					SelectorId
				);
		return UHyperTwistTrainingCoachLibrary::
			DeriveCoachGeneratedModeSelectorOptionOwnedExecutionRealScrambleVirtualCubeSmartCubeCapabilityRetentionPreviewSurface(
				RunState,
				SelectorId,
				OptionMenuSurface,
				OptionLaunchRequestPreviewSurface
			);
	}

	return FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionRealScrambleVirtualCubeSmartCubeCapabilityRetentionPreviewSurface();
}

FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionTimingPolicyRetentionPreviewSurface
UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachGeneratedModeSelectorOptionOwnedExecutionTimingPolicyRetentionPreviewSurface(
	UObject* WorldContextObject,
	const FString& SelectorId
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		const FHyperTwistTrainingRunState RunState = TrainingSubsystem->GetActiveRunState();
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionMenuSurface OptionMenuSurface =
			GetActiveTrainingCoachGeneratedModeSelectorOptionMenuSurface(
				WorldContextObject,
				SelectorId
			);
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface
			OptionLaunchRequestPreviewSurface =
				GetActiveTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface(
					WorldContextObject,
					SelectorId
				);
		return UHyperTwistTrainingCoachLibrary::
			DeriveCoachGeneratedModeSelectorOptionOwnedExecutionTimingPolicyRetentionPreviewSurface(
				RunState,
				SelectorId,
				OptionMenuSurface,
				OptionLaunchRequestPreviewSurface
			);
	}

	return FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionTimingPolicyRetentionPreviewSurface();
}

FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseDetailRetentionPreviewSurface
UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseDetailRetentionPreviewSurface(
	UObject* WorldContextObject,
	const FString& SelectorId
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		const FHyperTwistTrainingRunState RunState = TrainingSubsystem->GetActiveRunState();
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionMenuSurface OptionMenuSurface =
			GetActiveTrainingCoachGeneratedModeSelectorOptionMenuSurface(
				WorldContextObject,
				SelectorId
			);
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface
			OptionLaunchRequestPreviewSurface =
				GetActiveTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface(
					WorldContextObject,
					SelectorId
				);
		return UHyperTwistTrainingCoachLibrary::
			DeriveCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseDetailRetentionPreviewSurface(
				RunState,
				SelectorId,
				OptionMenuSurface,
				OptionLaunchRequestPreviewSurface
			);
	}

	return FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseDetailRetentionPreviewSurface();
}

FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhasePhaseIdLabelFallbackProvenancePreviewSurface
UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhasePhaseIdLabelFallbackProvenancePreviewSurface(
	UObject* WorldContextObject,
	const FString& SelectorId
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		const FHyperTwistTrainingRunState RunState = TrainingSubsystem->GetActiveRunState();
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionMenuSurface OptionMenuSurface =
			GetActiveTrainingCoachGeneratedModeSelectorOptionMenuSurface(
				WorldContextObject,
				SelectorId
			);
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface
			OptionLaunchRequestPreviewSurface =
				GetActiveTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface(
					WorldContextObject,
					SelectorId
				);
		return UHyperTwistTrainingCoachLibrary::
			DeriveCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhasePhaseIdLabelFallbackProvenancePreviewSurface(
				RunState,
				SelectorId,
				OptionMenuSurface,
				OptionLaunchRequestPreviewSurface
			);
	}

	return FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhasePhaseIdLabelFallbackProvenancePreviewSurface();
}

FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseDuplicatePruningSurvivorProvenancePreviewSurface
UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseDuplicatePruningSurvivorProvenancePreviewSurface(
	UObject* WorldContextObject,
	const FString& SelectorId
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		const FHyperTwistTrainingRunState RunState = TrainingSubsystem->GetActiveRunState();
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionMenuSurface OptionMenuSurface =
			GetActiveTrainingCoachGeneratedModeSelectorOptionMenuSurface(
				WorldContextObject,
				SelectorId
			);
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface
			OptionLaunchRequestPreviewSurface =
				GetActiveTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface(
					WorldContextObject,
					SelectorId
				);
		return UHyperTwistTrainingCoachLibrary::
			DeriveCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseDuplicatePruningSurvivorProvenancePreviewSurface(
				RunState,
				SelectorId,
				OptionMenuSurface,
				OptionLaunchRequestPreviewSurface
			);
	}

	return FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseDuplicatePruningSurvivorProvenancePreviewSurface();
}

FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseNormalizationSummaryPreviewSurface
UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseNormalizationSummaryPreviewSurface(
	UObject* WorldContextObject,
	const FString& SelectorId
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		const FHyperTwistTrainingRunState RunState = TrainingSubsystem->GetActiveRunState();
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionMenuSurface OptionMenuSurface =
			GetActiveTrainingCoachGeneratedModeSelectorOptionMenuSurface(
				WorldContextObject,
				SelectorId
			);
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface
			OptionLaunchRequestPreviewSurface =
				GetActiveTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface(
					WorldContextObject,
					SelectorId
				);
		return UHyperTwistTrainingCoachLibrary::
			DeriveCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseNormalizationSummaryPreviewSurface(
				RunState,
				SelectorId,
				OptionMenuSurface,
				OptionLaunchRequestPreviewSurface
			);
	}

	return FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseNormalizationSummaryPreviewSurface();
}

FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseRawRowNormalizedPhaseFusionPreviewSurface
UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseRawRowNormalizedPhaseFusionPreviewSurface(
	UObject* WorldContextObject,
	const FString& SelectorId
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		const FHyperTwistTrainingRunState RunState = TrainingSubsystem->GetActiveRunState();
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionMenuSurface OptionMenuSurface =
			GetActiveTrainingCoachGeneratedModeSelectorOptionMenuSurface(
				WorldContextObject,
				SelectorId
			);
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface
			OptionLaunchRequestPreviewSurface =
				GetActiveTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface(
					WorldContextObject,
					SelectorId
				);
		return UHyperTwistTrainingCoachLibrary::
			DeriveCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseRawRowNormalizedPhaseFusionPreviewSurface(
				RunState,
				SelectorId,
				OptionMenuSurface,
				OptionLaunchRequestPreviewSurface
			);
	}

	return FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseRawRowNormalizedPhaseFusionPreviewSurface();
}

FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseCurrentSelectionCanonicalInspectSurface
UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseCurrentSelectionCanonicalInspectSurface(
	UObject* WorldContextObject,
	const FString& SelectorId
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		const FHyperTwistTrainingRunState RunState = TrainingSubsystem->GetActiveRunState();
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionMenuSurface OptionMenuSurface =
			GetActiveTrainingCoachGeneratedModeSelectorOptionMenuSurface(
				WorldContextObject,
				SelectorId
			);
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface
			OptionLaunchRequestPreviewSurface =
				GetActiveTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface(
					WorldContextObject,
					SelectorId
				);
		return UHyperTwistTrainingCoachLibrary::
			DeriveCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseCurrentSelectionCanonicalInspectSurface(
				RunState,
				SelectorId,
				OptionMenuSurface,
				OptionLaunchRequestPreviewSurface
			);
	}

	return FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseCurrentSelectionCanonicalInspectSurface();
}

FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseCurrentSelectionSurvivorPhaseRosterInspectSurface
UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseCurrentSelectionSurvivorPhaseRosterInspectSurface(
	UObject* WorldContextObject,
	const FString& SelectorId
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		const FHyperTwistTrainingRunState RunState = TrainingSubsystem->GetActiveRunState();
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionMenuSurface OptionMenuSurface =
			GetActiveTrainingCoachGeneratedModeSelectorOptionMenuSurface(
				WorldContextObject,
				SelectorId
			);
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface
			OptionLaunchRequestPreviewSurface =
				GetActiveTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface(
					WorldContextObject,
					SelectorId
				);
		return UHyperTwistTrainingCoachLibrary::
			DeriveCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseCurrentSelectionSurvivorPhaseRosterInspectSurface(
				RunState,
				SelectorId,
				OptionMenuSurface,
				OptionLaunchRequestPreviewSurface
			);
	}

	return FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseCurrentSelectionSurvivorPhaseRosterInspectSurface();
}

FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseCurrentSelectionDroppedRowAuditInspectSurface
UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseCurrentSelectionDroppedRowAuditInspectSurface(
	UObject* WorldContextObject,
	const FString& SelectorId
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		const FHyperTwistTrainingRunState RunState = TrainingSubsystem->GetActiveRunState();
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionMenuSurface OptionMenuSurface =
			GetActiveTrainingCoachGeneratedModeSelectorOptionMenuSurface(
				WorldContextObject,
				SelectorId
			);
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface
			OptionLaunchRequestPreviewSurface =
				GetActiveTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface(
					WorldContextObject,
					SelectorId
				);
		return UHyperTwistTrainingCoachLibrary::
			DeriveCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseCurrentSelectionDroppedRowAuditInspectSurface(
				RunState,
				SelectorId,
				OptionMenuSurface,
				OptionLaunchRequestPreviewSurface
			);
	}

	return FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseCurrentSelectionDroppedRowAuditInspectSurface();
}

FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseCurrentSelectionPhaseIdFallbackRosterInspectSurface
UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseCurrentSelectionPhaseIdFallbackRosterInspectSurface(
	UObject* WorldContextObject,
	const FString& SelectorId
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		const FHyperTwistTrainingRunState RunState = TrainingSubsystem->GetActiveRunState();
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionMenuSurface OptionMenuSurface =
			GetActiveTrainingCoachGeneratedModeSelectorOptionMenuSurface(
				WorldContextObject,
				SelectorId
			);
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface
			OptionLaunchRequestPreviewSurface =
				GetActiveTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface(
					WorldContextObject,
					SelectorId
				);
		return UHyperTwistTrainingCoachLibrary::
			DeriveCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseCurrentSelectionPhaseIdFallbackRosterInspectSurface(
				RunState,
				SelectorId,
				OptionMenuSurface,
				OptionLaunchRequestPreviewSurface
			);
	}

	return FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseCurrentSelectionPhaseIdFallbackRosterInspectSurface();
}

FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseCurrentSelectionExplicitLabelRosterInspectSurface
UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseCurrentSelectionExplicitLabelRosterInspectSurface(
	UObject* WorldContextObject,
	const FString& SelectorId
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		const FHyperTwistTrainingRunState RunState = TrainingSubsystem->GetActiveRunState();
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionMenuSurface OptionMenuSurface =
			GetActiveTrainingCoachGeneratedModeSelectorOptionMenuSurface(
				WorldContextObject,
				SelectorId
			);
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface
			OptionLaunchRequestPreviewSurface =
				GetActiveTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface(
					WorldContextObject,
					SelectorId
				);
		return UHyperTwistTrainingCoachLibrary::
			DeriveCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseCurrentSelectionExplicitLabelRosterInspectSurface(
				RunState,
				SelectorId,
				OptionMenuSurface,
				OptionLaunchRequestPreviewSurface
			);
	}

	return FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseCurrentSelectionExplicitLabelRosterInspectSurface();
}

FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseCurrentSelectionLabelProvenancePartitionSummaryInspectSurface
UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseCurrentSelectionLabelProvenancePartitionSummaryInspectSurface(
	UObject* WorldContextObject,
	const FString& SelectorId
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		const FHyperTwistTrainingRunState RunState = TrainingSubsystem->GetActiveRunState();
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionMenuSurface OptionMenuSurface =
			GetActiveTrainingCoachGeneratedModeSelectorOptionMenuSurface(
				WorldContextObject,
				SelectorId
			);
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface
			OptionLaunchRequestPreviewSurface =
				GetActiveTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface(
					WorldContextObject,
					SelectorId
				);
		return UHyperTwistTrainingCoachLibrary::
			DeriveCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseCurrentSelectionLabelProvenancePartitionSummaryInspectSurface(
				RunState,
				SelectorId,
				OptionMenuSurface,
				OptionLaunchRequestPreviewSurface
			);
	}

	return FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseCurrentSelectionLabelProvenancePartitionSummaryInspectSurface();
}

FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseCurrentSelectionLabelProvenancePartitionRosterPairInspectSurface
UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseCurrentSelectionLabelProvenancePartitionRosterPairInspectSurface(
	UObject* WorldContextObject,
	const FString& SelectorId
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		const FHyperTwistTrainingRunState RunState = TrainingSubsystem->GetActiveRunState();
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionMenuSurface OptionMenuSurface =
			GetActiveTrainingCoachGeneratedModeSelectorOptionMenuSurface(
				WorldContextObject,
				SelectorId
			);
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface
			OptionLaunchRequestPreviewSurface =
				GetActiveTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface(
					WorldContextObject,
					SelectorId
				);
		return UHyperTwistTrainingCoachLibrary::
			DeriveCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseCurrentSelectionLabelProvenancePartitionRosterPairInspectSurface(
				RunState,
				SelectorId,
				OptionMenuSurface,
				OptionLaunchRequestPreviewSurface
			);
	}

	return FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseCurrentSelectionLabelProvenancePartitionRosterPairInspectSurface();
}

FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseCurrentSelectionLabelProvenancePartitionMergedOrderedRosterInspectSurface
UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseCurrentSelectionLabelProvenancePartitionMergedOrderedRosterInspectSurface(
	UObject* WorldContextObject,
	const FString& SelectorId
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		const FHyperTwistTrainingRunState RunState = TrainingSubsystem->GetActiveRunState();
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionMenuSurface OptionMenuSurface =
			GetActiveTrainingCoachGeneratedModeSelectorOptionMenuSurface(
				WorldContextObject,
				SelectorId
			);
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface
			OptionLaunchRequestPreviewSurface =
				GetActiveTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface(
					WorldContextObject,
					SelectorId
				);
		return UHyperTwistTrainingCoachLibrary::
			DeriveCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseCurrentSelectionLabelProvenancePartitionMergedOrderedRosterInspectSurface(
				RunState,
				SelectorId,
				OptionMenuSurface,
				OptionLaunchRequestPreviewSurface
			);
	}

	return FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseCurrentSelectionLabelProvenancePartitionMergedOrderedRosterInspectSurface();
}

FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseCurrentSelectionLabelProvenancePartitionMergedOrderedRosterPhaseIdLookupInspectSurface
UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseCurrentSelectionLabelProvenancePartitionMergedOrderedRosterPhaseIdLookupInspectSurface(
	UObject* WorldContextObject,
	const FString& SelectorId,
	const FString& PhaseId
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		const FHyperTwistTrainingRunState RunState = TrainingSubsystem->GetActiveRunState();
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionMenuSurface OptionMenuSurface =
			GetActiveTrainingCoachGeneratedModeSelectorOptionMenuSurface(
				WorldContextObject,
				SelectorId
			);
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface
			OptionLaunchRequestPreviewSurface =
				GetActiveTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface(
					WorldContextObject,
					SelectorId
				);
		return UHyperTwistTrainingCoachLibrary::
			DeriveCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseCurrentSelectionLabelProvenancePartitionMergedOrderedRosterPhaseIdLookupInspectSurface(
				RunState,
				SelectorId,
				PhaseId,
				OptionMenuSurface,
				OptionLaunchRequestPreviewSurface
			);
	}

	return FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseCurrentSelectionLabelProvenancePartitionMergedOrderedRosterPhaseIdLookupInspectSurface();
}

FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseCurrentSelectionLabelProvenancePartitionMergedOrderedRosterNormalizedOrderLookupInspectSurface
UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseCurrentSelectionLabelProvenancePartitionMergedOrderedRosterNormalizedOrderLookupInspectSurface(
	UObject* WorldContextObject,
	const FString& SelectorId,
	const int32 NormalizedOrder
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		const FHyperTwistTrainingRunState RunState = TrainingSubsystem->GetActiveRunState();
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionMenuSurface OptionMenuSurface =
			GetActiveTrainingCoachGeneratedModeSelectorOptionMenuSurface(
				WorldContextObject,
				SelectorId
			);
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface
			OptionLaunchRequestPreviewSurface =
				GetActiveTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface(
					WorldContextObject,
					SelectorId
				);
		return UHyperTwistTrainingCoachLibrary::
			DeriveCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseCurrentSelectionLabelProvenancePartitionMergedOrderedRosterNormalizedOrderLookupInspectSurface(
				RunState,
				SelectorId,
				NormalizedOrder,
				OptionMenuSurface,
				OptionLaunchRequestPreviewSurface
			);
	}

	return FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseCurrentSelectionLabelProvenancePartitionMergedOrderedRosterNormalizedOrderLookupInspectSurface();
}

FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseCurrentSelectionLabelProvenancePartitionMergedOrderedRosterEvaluationOrderLookupInspectSurface
UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseCurrentSelectionLabelProvenancePartitionMergedOrderedRosterEvaluationOrderLookupInspectSurface(
	UObject* WorldContextObject,
	const FString& SelectorId,
	const int32 EvaluationOrder
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		const FHyperTwistTrainingRunState RunState = TrainingSubsystem->GetActiveRunState();
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionMenuSurface OptionMenuSurface =
			GetActiveTrainingCoachGeneratedModeSelectorOptionMenuSurface(
				WorldContextObject,
				SelectorId
			);
		const FHyperTwistTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface
			OptionLaunchRequestPreviewSurface =
				GetActiveTrainingCoachGeneratedModeSelectorOptionLaunchRequestPreviewSurface(
					WorldContextObject,
					SelectorId
				);
		return UHyperTwistTrainingCoachLibrary::
			DeriveCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseCurrentSelectionLabelProvenancePartitionMergedOrderedRosterEvaluationOrderLookupInspectSurface(
				RunState,
				SelectorId,
				EvaluationOrder,
				OptionMenuSurface,
				OptionLaunchRequestPreviewSurface
			);
	}

	return FHyperTwistTrainingCoachGeneratedModeSelectorOptionOwnedExecutionSplitPhaseCurrentSelectionLabelProvenancePartitionMergedOrderedRosterEvaluationOrderLookupInspectSurface();
}

TArray<FHyperTwistTrainingMethodSegment> UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingLearnerMethodSegments(UObject* WorldContextObject)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->GetActiveLearnerMethodSegments();
	}

	return TArray<FHyperTwistTrainingMethodSegment>();
}

TArray<FHyperTwistTrainingLearnerPreset> UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingLearnerPresets(UObject* WorldContextObject)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->GetActiveLearnerPresets();
	}

	return TArray<FHyperTwistTrainingLearnerPreset>();
}

TArray<FHyperTwistTrainingSessionTemplate> UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingSessionTemplates(UObject* WorldContextObject)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->GetActiveTrainingSessionTemplates();
	}

	return TArray<FHyperTwistTrainingSessionTemplate>();
}

TArray<FHyperTwistTrainingSessionTemplate> UHyperTwistTrainingRuntimeLibrary::GetTrainingSessionTemplatesForUser(
	UObject* WorldContextObject,
	const FString& UserId,
	const FString& ReferenceUtc
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->GetTrainingSessionTemplatesForUser(UserId, ReferenceUtc);
	}

	return TArray<FHyperTwistTrainingSessionTemplate>();
}

TArray<FHyperTwistTrainingMethodDrillFavoriteEntry> UHyperTwistTrainingRuntimeLibrary::GetMethodDrillFavoritesForUser(
	UObject* WorldContextObject,
	const FString& UserId,
	const FString& MethodSegmentId
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->GetMethodDrillFavoritesForUser(UserId, MethodSegmentId);
	}

	return TArray<FHyperTwistTrainingMethodDrillFavoriteEntry>();
}

TArray<FHyperTwistTrainingMethodDrillBatch> UHyperTwistTrainingRuntimeLibrary::GetMethodDrillBatchesForUser(
	UObject* WorldContextObject,
	const FString& UserId,
	const FString& MethodSegmentId
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->GetMethodDrillBatchesForUser(UserId, MethodSegmentId);
	}

	return TArray<FHyperTwistTrainingMethodDrillBatch>();
}

TArray<FHyperTwistTrainingMethodDrillBatch> UHyperTwistTrainingRuntimeLibrary::GetResumableMethodDrillBatchesForUser(
	UObject* WorldContextObject,
	const FString& UserId,
	const FString& MethodSegmentId
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->GetResumableMethodDrillBatchesForUser(UserId, MethodSegmentId);
	}

	return TArray<FHyperTwistTrainingMethodDrillBatch>();
}

FHyperTwistTrainingMethodDrillBatchReadiness UHyperTwistTrainingRuntimeLibrary::DeriveMethodDrillBatchReadiness(
	UObject* WorldContextObject,
	const FHyperTwistTrainingMethodDrillBatch& DrillBatch,
	const FHyperTwistTrainingMethodDrillDefinition& DrillDefinition
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->DeriveMethodDrillBatchReadiness(DrillBatch, DrillDefinition);
	}

	return FHyperTwistTrainingMethodDrillBatchReadiness();
}

FHyperTwistTrainingMethodDrillBatch UHyperTwistTrainingRuntimeLibrary::RebuildMethodDrillBatchForResume(
	UObject* WorldContextObject,
	const FHyperTwistTrainingMethodDrillBatch& DrillBatch,
	const FHyperTwistTrainingMethodDrillDefinition& DrillDefinition
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->RebuildMethodDrillBatchForResume(DrillBatch, DrillDefinition);
	}

	return FHyperTwistTrainingMethodDrillBatch();
}

FHyperTwistTrainingMethodDrillDefinition UHyperTwistTrainingRuntimeLibrary::BuildFavoriteFirstMethodDrillDefinition(
	UObject* WorldContextObject,
	const FHyperTwistTrainingMethodDrillDefinition& BaseDefinition,
	const FString& UserId,
	int32 MaxFavoriteCases
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->BuildFavoriteFirstMethodDrillDefinition(
			BaseDefinition,
			UserId,
			MaxFavoriteCases
		);
	}

	return FHyperTwistTrainingMethodDrillDefinition();
}

TArray<FHyperTwistTrainingCaseRecommendation> UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingCaseRecommendations(UObject* WorldContextObject)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->GetActiveCaseRecommendations();
	}

	return TArray<FHyperTwistTrainingCaseRecommendation>();
}

FHyperTwistTrainingReviewPlanState UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingReviewPlanState(UObject* WorldContextObject)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->GetActiveReviewPlanState();
	}

	return FHyperTwistTrainingReviewPlanState();
}

FHyperTwistTrainingReviewFlowStatus UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingReviewFlowStatus(UObject* WorldContextObject)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->GetActiveReviewFlowStatus();
	}

	return FHyperTwistTrainingReviewFlowStatus();
}

FHyperTwistTrainingReviewProgramSummary UHyperTwistTrainingRuntimeLibrary::GetActiveTrainingReviewProgramSummary(UObject* WorldContextObject)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->GetActiveReviewProgramSummary();
	}

	return FHyperTwistTrainingReviewProgramSummary();
}

FHyperTwistTrainingTimerExportPacket UHyperTwistTrainingRuntimeLibrary::BuildTrainingTimerExportPacket(
	UObject* WorldContextObject,
	const FString& UserId,
	const FString& DeckId,
	const FString& ReferenceUtc
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->BuildTrainingTimerExportPacket(UserId, DeckId, ReferenceUtc);
	}

	return FHyperTwistTrainingTimerExportPacket();
}

bool UHyperTwistTrainingRuntimeLibrary::TryGetStoredTrainingRunRecord(
	UObject* WorldContextObject,
	const FString& TrainingSessionId,
	FHyperTwistTrainingRunRecord& OutRunRecord
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->TryGetStoredRunRecord(TrainingSessionId, OutRunRecord);
	}

	OutRunRecord = FHyperTwistTrainingRunRecord();
	return false;
}

bool UHyperTwistTrainingRuntimeLibrary::TryGetStoredTrainingLearnerState(
	UObject* WorldContextObject,
	const FString& UserId,
	const FString& DeckId,
	const FString& CaseId,
	FHyperTwistTrainingCaseLearnerState& OutLearnerState
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->TryGetStoredLearnerState(UserId, DeckId, CaseId, OutLearnerState);
	}

	OutLearnerState = FHyperTwistTrainingCaseLearnerState();
	return false;
}

bool UHyperTwistTrainingRuntimeLibrary::TryGetStoredTrainingReviewPlan(
	UObject* WorldContextObject,
	const FString& PlanId,
	FHyperTwistTrainingReviewPlanState& OutReviewPlan
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->TryGetStoredReviewPlan(PlanId, OutReviewPlan);
	}

	OutReviewPlan = FHyperTwistTrainingReviewPlanState();
	return false;
}

bool UHyperTwistTrainingRuntimeLibrary::TryGetStoredTrainingCoachActionPlan(
	UObject* WorldContextObject,
	const FString& PlanId,
	FHyperTwistTrainingCoachActionPlan& OutActionPlan
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->TryGetStoredCoachActionPlan(PlanId, OutActionPlan);
	}

	OutActionPlan = FHyperTwistTrainingCoachActionPlan();
	return false;
}

bool UHyperTwistTrainingRuntimeLibrary::TryGetStoredTrainingCoachSessionQueueState(
	UObject* WorldContextObject,
	const FString& UserId,
	const FString& QueueId,
	FHyperTwistTrainingCoachSessionQueueState& OutQueueState
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->TryGetStoredCoachSessionQueueState(UserId, QueueId, OutQueueState);
	}

	OutQueueState = FHyperTwistTrainingCoachSessionQueueState();
	return false;
}

bool UHyperTwistTrainingRuntimeLibrary::TryGetStoredTrainingSessionTemplate(
	UObject* WorldContextObject,
	const FString& UserId,
	const FString& TemplateId,
	FHyperTwistTrainingSessionTemplate& OutTemplate
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->TryGetStoredTrainingSessionTemplate(UserId, TemplateId, OutTemplate);
	}

	OutTemplate = FHyperTwistTrainingSessionTemplate();
	return false;
}

bool UHyperTwistTrainingRuntimeLibrary::SaveTrainingSessionTemplate(
	UObject* WorldContextObject,
	const FHyperTwistTrainingSessionTemplate& SessionTemplate
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->SaveTrainingSessionTemplate(SessionTemplate);
	}

	return false;
}

bool UHyperTwistTrainingRuntimeLibrary::SaveMethodDrillFavorite(
	UObject* WorldContextObject,
	const FHyperTwistTrainingMethodDrillFavoriteEntry& FavoriteEntry
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->SaveMethodDrillFavorite(FavoriteEntry);
	}

	return false;
}

bool UHyperTwistTrainingRuntimeLibrary::RemoveMethodDrillFavorite(
	UObject* WorldContextObject,
	const FString& UserId,
	const FString& DrillId,
	const FString& CaseId
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->RemoveMethodDrillFavorite(UserId, DrillId, CaseId);
	}

	return false;
}

bool UHyperTwistTrainingRuntimeLibrary::TryGetStoredMethodDrillBatch(
	UObject* WorldContextObject,
	const FString& UserId,
	const FString& BatchId,
	FHyperTwistTrainingMethodDrillBatch& OutBatch
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->TryGetStoredMethodDrillBatch(UserId, BatchId, OutBatch);
	}

	OutBatch = FHyperTwistTrainingMethodDrillBatch();
	return false;
}

bool UHyperTwistTrainingRuntimeLibrary::SaveMethodDrillBatch(
	UObject* WorldContextObject,
	const FHyperTwistTrainingMethodDrillBatch& DrillBatch
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->SaveMethodDrillBatch(DrillBatch);
	}

	return false;
}

bool UHyperTwistTrainingRuntimeLibrary::SaveCoachSessionQueueState(
	UObject* WorldContextObject,
	const FHyperTwistTrainingCoachSessionQueueState& QueueState
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->SaveCoachSessionQueueState(QueueState);
	}

	return false;
}

bool UHyperTwistTrainingRuntimeLibrary::DeferCoachSessionQueueEntry(
	UObject* WorldContextObject,
	const FString& EntryId,
	const FString& DeferredUntilUtc,
	const FString& DeferralReasonLabel,
	bool bManualReschedule
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->DeferCoachSessionQueueEntry(
			EntryId,
			DeferredUntilUtc,
			DeferralReasonLabel,
			bManualReschedule
		);
	}

	return false;
}

bool UHyperTwistTrainingRuntimeLibrary::PromoteCoachSessionQueueEntry(
	UObject* WorldContextObject,
	const FString& EntryId,
	const FString& StartActionSourceLabel
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->PromoteCoachSessionQueueEntry(
			EntryId,
			StartActionSourceLabel
		);
	}

	return false;
}

bool UHyperTwistTrainingRuntimeLibrary::DeferDisplayedCoachQueueEntry(
	UObject* WorldContextObject,
	const FString& DeferredUntilUtc,
	const FString& DeferralReasonLabel,
	const bool bManualReschedule
)
{
	const FHyperTwistTrainingCoachQueueControlSurface Surface =
		GetActiveTrainingCoachQueueControlSurface(WorldContextObject);
	if (!Surface.bCanDefer || Surface.DeferTargetEntryId.IsEmpty())
	{
		return false;
	}

	return DeferCoachSessionQueueEntry(
		WorldContextObject,
		Surface.DeferTargetEntryId,
		DeferredUntilUtc,
		DeferralReasonLabel,
		bManualReschedule
	);
}

bool UHyperTwistTrainingRuntimeLibrary::PromoteDisplayedCoachQueueEntry(UObject* WorldContextObject)
{
	const FHyperTwistTrainingCoachQueueControlSurface Surface =
		GetActiveTrainingCoachQueueControlSurface(WorldContextObject);
	if (!Surface.bCanPromote || Surface.PromoteTargetEntryId.IsEmpty())
	{
		return false;
	}

	return PromoteCoachSessionQueueEntry(
		WorldContextObject,
		Surface.PromoteTargetEntryId,
		Surface.PromoteActionSourceLabel
	);
}

bool UHyperTwistTrainingRuntimeLibrary::RemoveMethodDrillBatch(
	UObject* WorldContextObject,
	const FString& UserId,
	const FString& BatchId
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->RemoveMethodDrillBatch(UserId, BatchId);
	}

	return false;
}

bool UHyperTwistTrainingRuntimeLibrary::RemoveTrainingSessionTemplate(
	UObject* WorldContextObject,
	const FString& UserId,
	const FString& TemplateId
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->RemoveTrainingSessionTemplate(UserId, TemplateId);
	}

	return false;
}

bool UHyperTwistTrainingRuntimeLibrary::SaveTrainingRepositoryStateToDefaultPath(
	UObject* WorldContextObject,
	FString& OutResolvedPath
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->SaveTrainingRepositoryStateToDefaultPath(OutResolvedPath);
	}

	OutResolvedPath.Reset();
	return false;
}

bool UHyperTwistTrainingRuntimeLibrary::LoadTrainingRepositoryStateFromDefaultPath(
	UObject* WorldContextObject,
	FString& OutResolvedPath
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->LoadTrainingRepositoryStateFromDefaultPath(OutResolvedPath);
	}

	OutResolvedPath.Reset();
	return false;
}

FHyperTwistTrainingRepositoryRoundTripVerification
UHyperTwistTrainingRuntimeLibrary::VerifyTrainingRepositoryRoundTripAtDefaultPath(
	UObject* WorldContextObject
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->VerifyTrainingRepositoryRoundTripAtDefaultPath();
	}

	return FHyperTwistTrainingRepositoryRoundTripVerification();
}

bool UHyperTwistTrainingRuntimeLibrary::SaveTrainingTimerExportPacketToDefaultPath(
	UObject* WorldContextObject,
	const FString& UserId,
	const FString& DeckId,
	FString& OutResolvedPath
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->SaveTrainingTimerExportPacketToDefaultPath(UserId, DeckId, OutResolvedPath);
	}

	OutResolvedPath.Reset();
	return false;
}

bool UHyperTwistTrainingRuntimeLibrary::ImportTrainingTimerExportPacket(
	UObject* WorldContextObject,
	const FHyperTwistTrainingTimerExportPacket& TimerExportPacket
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->ImportTrainingTimerExportPacket(TimerExportPacket);
	}

	return false;
}

bool UHyperTwistTrainingRuntimeLibrary::LoadTrainingTimerExportPacketFromFile(
	UObject* WorldContextObject,
	const FString& UserId,
	const FString& DeckId,
	const FString& ExportPath,
	FString& OutResolvedPath
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->LoadTrainingTimerExportPacketFromFile(UserId, DeckId, ExportPath, OutResolvedPath);
	}

	OutResolvedPath.Reset();
	return false;
}

bool UHyperTwistTrainingRuntimeLibrary::TryMaterializeActiveTrainingSessionTemplate(
	UObject* WorldContextObject,
	const FString& TemplateId,
	FHyperTwistTrainingDeck& OutDeck
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->TryMaterializeActiveTrainingSessionTemplate(TemplateId, OutDeck);
	}

	OutDeck = FHyperTwistTrainingDeck();
	return false;
}

bool UHyperTwistTrainingRuntimeLibrary::TryMaterializeTrainingSessionTemplateForUser(
	UObject* WorldContextObject,
	const FString& UserId,
	const FString& TemplateId,
	const FString& ReferenceUtc,
	FHyperTwistTrainingDeck& OutDeck
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->TryMaterializeTrainingSessionTemplateForUser(
			UserId,
			TemplateId,
			ReferenceUtc,
			OutDeck
		);
	}

	OutDeck = FHyperTwistTrainingDeck();
	return false;
}

FHyperTwistTrainingDeck UHyperTwistTrainingRuntimeLibrary::BuildActiveReviewDeck(
	UObject* WorldContextObject,
	int32 MaxCases
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->BuildActiveReviewDeck(MaxCases);
	}

	return FHyperTwistTrainingDeck();
}

FHyperTwistTrainingDeck UHyperTwistTrainingRuntimeLibrary::BuildActiveCoachRecommendedDeck(
	UObject* WorldContextObject,
	int32 MaxCases
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->BuildActiveCoachRecommendedDeck(MaxCases);
	}

	return FHyperTwistTrainingDeck();
}

FHyperTwistTrainingDeck UHyperTwistTrainingRuntimeLibrary::BuildActiveCoachFollowUpDeck(
	UObject* WorldContextObject,
	int32 MaxCases
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->BuildActiveCoachFollowUpDeck(MaxCases);
	}

	return FHyperTwistTrainingDeck();
}

FHyperTwistTrainingDeck UHyperTwistTrainingRuntimeLibrary::BuildActiveMethodDrillFollowUpDeck(
	UObject* WorldContextObject
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->BuildActiveMethodDrillFollowUpDeck();
	}

	return FHyperTwistTrainingDeck();
}

FHyperTwistTrainingRunState UHyperTwistTrainingRuntimeLibrary::StartTrainingRunFromTemplate(
	UObject* WorldContextObject,
	const FString& TemplateId,
	const FString& UserId,
	const FString& SessionId
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->StartTrainingRunFromTemplate(TemplateId, UserId, SessionId);
	}

	return FHyperTwistTrainingRunState();
}

FHyperTwistTrainingRunState UHyperTwistTrainingRuntimeLibrary::StartActiveMethodDrillFollowUpRun(
	UObject* WorldContextObject,
	const FString& SessionId
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->StartActiveMethodDrillFollowUpRun(SessionId);
	}

	return FHyperTwistTrainingRunState();
}

FHyperTwistTrainingRunState UHyperTwistTrainingRuntimeLibrary::StartRecommendedReviewRun(
	UObject* WorldContextObject,
	const FString& SessionId,
	int32 MaxCases,
	EHyperTwistTrainingDeliveryMode Mode
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->StartRecommendedReviewRun(SessionId, MaxCases, Mode);
	}

	return FHyperTwistTrainingRunState();
}

FHyperTwistTrainingRunState UHyperTwistTrainingRuntimeLibrary::StartCoachRecommendedRun(
	UObject* WorldContextObject,
	const FString& SessionId,
	int32 MaxCases,
	const FString& StartActionSourceLabel
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->StartCoachRecommendedRun(SessionId, MaxCases, StartActionSourceLabel);
	}

	return FHyperTwistTrainingRunState();
}

FHyperTwistTrainingRunState UHyperTwistTrainingRuntimeLibrary::StartCoachFollowUpRun(
	UObject* WorldContextObject,
	const FString& SessionId,
	int32 MaxCases,
	const FString& StartActionSourceLabel
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->StartCoachFollowUpRun(SessionId, MaxCases, StartActionSourceLabel);
	}

	return FHyperTwistTrainingRunState();
}

FHyperTwistTrainingRunState UHyperTwistTrainingRuntimeLibrary::StartPrimaryCoachAction(
	UObject* WorldContextObject,
	const FString& SessionId,
	int32 MaxCases,
	const FString& StartActionSourceLabel
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->StartPrimaryCoachAction(SessionId, MaxCases, StartActionSourceLabel);
	}

	return FHyperTwistTrainingRunState();
}

FHyperTwistTrainingRunState UHyperTwistTrainingRuntimeLibrary::StartNextQueuedCoachRun(
	UObject* WorldContextObject,
	const FString& SessionId,
	int32 MaxCases,
	const FString& StartActionSourceLabel
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->StartNextQueuedCoachRun(SessionId, MaxCases, StartActionSourceLabel);
	}

	return FHyperTwistTrainingRunState();
}

FHyperTwistTrainingRunState UHyperTwistTrainingRuntimeLibrary::StartCoachQueueEntry(
	UObject* WorldContextObject,
	const FString& EntryId,
	const FString& SessionId,
	int32 MaxCases
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->StartCoachQueueEntry(EntryId, SessionId, MaxCases);
	}

	return FHyperTwistTrainingRunState();
}

FHyperTwistTrainingRunState UHyperTwistTrainingRuntimeLibrary::StartDisplayedCoachRecommendedRun(
	UObject* WorldContextObject,
	const FString& SessionId,
	const int32 MaxCases
)
{
	return StartCoachRecommendedRun(
		WorldContextObject,
		SessionId,
		MaxCases,
		ResolveActiveTrainingCoachHandoffStartActionSourceLabel(
			WorldContextObject,
			EHyperTwistTrainingCoachHandoffKind::Recommended
		)
	);
}

FHyperTwistTrainingRunState UHyperTwistTrainingRuntimeLibrary::StartDisplayedCoachFollowUpRun(
	UObject* WorldContextObject,
	const FString& SessionId,
	const int32 MaxCases
)
{
	return StartCoachFollowUpRun(
		WorldContextObject,
		SessionId,
		MaxCases,
		ResolveActiveTrainingCoachHandoffStartActionSourceLabel(
			WorldContextObject,
			EHyperTwistTrainingCoachHandoffKind::FollowUp
		)
	);
}

FHyperTwistTrainingRunState UHyperTwistTrainingRuntimeLibrary::StartDisplayedPrimaryCoachAction(
	UObject* WorldContextObject,
	const FString& SessionId,
	const int32 MaxCases
)
{
	return StartPrimaryCoachAction(
		WorldContextObject,
		SessionId,
		MaxCases,
		ResolveActiveTrainingPrimaryCoachActionStartActionSourceLabel(WorldContextObject)
	);
}

FHyperTwistTrainingRunState UHyperTwistTrainingRuntimeLibrary::StartDisplayedNextQueuedCoachRun(
	UObject* WorldContextObject,
	const FString& SessionId,
	const int32 MaxCases
)
{
	return StartNextQueuedCoachRun(
		WorldContextObject,
		SessionId,
		MaxCases,
		ResolveActiveTrainingCoachHandoffStartActionSourceLabel(
			WorldContextObject,
			EHyperTwistTrainingCoachHandoffKind::Queue
		)
	);
}

FHyperTwistTrainingRunState UHyperTwistTrainingRuntimeLibrary::StartDisplayedCoachQueueEntry(
	UObject* WorldContextObject,
	const FString& SessionId,
	const int32 MaxCases
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		const FHyperTwistTrainingCoachPanelState PanelState = TrainingSubsystem->GetActiveCoachPanelState();
		if (PanelState.ActiveQueueEntryId.IsEmpty())
		{
			return FHyperTwistTrainingRunState();
		}

		return StartCoachQueueEntry(
			WorldContextObject,
			PanelState.ActiveQueueEntryId,
			SessionId,
			MaxCases
		);
	}

	return FHyperTwistTrainingRunState();
}

FHyperTwistTrainingRunState UHyperTwistTrainingRuntimeLibrary::StartSampleClassicTrainingRun(
	UObject* WorldContextObject,
	const FString& UserId,
	const FString& SessionId,
	EHyperTwistTrainingDeliveryMode Mode
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->StartSampleClassicTrainingRun(UserId, SessionId, Mode);
	}

	return FHyperTwistTrainingRunState();
}

FHyperTwistTrainingRunState UHyperTwistTrainingRuntimeLibrary::StartTrainingRunFromDeck(
	UObject* WorldContextObject,
	const FHyperTwistTrainingDeck& Deck,
	const FString& UserId,
	const FString& SessionId,
	EHyperTwistTrainingDeliveryMode Mode
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->StartTrainingRunFromDeck(Deck, UserId, SessionId, Mode);
	}

	return FHyperTwistTrainingRunState();
}

FHyperTwistTrainingRunState UHyperTwistTrainingRuntimeLibrary::StartTrainingRunFromImportedDeckId(
	UObject* WorldContextObject,
	const FString& DeckId,
	const FString& UserId,
	const FString& SessionId,
	EHyperTwistTrainingDeliveryMode Mode
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->StartTrainingRunFromImportedDeckId(DeckId, UserId, SessionId, Mode);
	}

	return FHyperTwistTrainingRunState();
}

FHyperTwistTrainingRunStepResult UHyperTwistTrainingRuntimeLibrary::SubmitTrainingAttempt(
	UObject* WorldContextObject,
	const FHyperTwistTrainingAttempt& Attempt,
	int32 TimeMs
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->SubmitTrainingAttempt(Attempt, TimeMs);
	}

	return FHyperTwistTrainingRunStepResult();
}

FHyperTwistTrainingMethodDrillRunState UHyperTwistTrainingRuntimeLibrary::StartMethodDrillRun(
	UObject* WorldContextObject,
	const FHyperTwistTrainingMethodDrillDefinition& DrillDefinition,
	const FString& UserId,
	const FString& RunId
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->StartMethodDrillRun(DrillDefinition, UserId, RunId);
	}

	return FHyperTwistTrainingMethodDrillRunState();
}

FHyperTwistTrainingMethodDrillRunState UHyperTwistTrainingRuntimeLibrary::StartMethodDrillRunFromDeck(
	UObject* WorldContextObject,
	const FHyperTwistTrainingDeck& Deck,
	const FString& UserId,
	const FString& RunId,
	EHyperTwistTrainingDrillModeKind DrillMode,
	EHyperTwistTrainingDrillVisibilityPolicy VisibilityPolicy,
	bool bAnswerHiddenUntilReveal
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->StartMethodDrillRunFromDeck(
			Deck,
			UserId,
			RunId,
			DrillMode,
			VisibilityPolicy,
			bAnswerHiddenUntilReveal
		);
	}

	return FHyperTwistTrainingMethodDrillRunState();
}

FHyperTwistTrainingMethodDrillRunState UHyperTwistTrainingRuntimeLibrary::ResumeMethodDrillRunFromBatch(
	UObject* WorldContextObject,
	const FHyperTwistTrainingMethodDrillDefinition& DrillDefinition,
	const FHyperTwistTrainingMethodDrillBatch& DrillBatch,
	const FString& RunId
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->ResumeMethodDrillRunFromBatch(DrillDefinition, DrillBatch, RunId);
	}

	return FHyperTwistTrainingMethodDrillRunState();
}

FHyperTwistTrainingMethodDrillRunState UHyperTwistTrainingRuntimeLibrary::StartNextActiveMethodDrillCase(
	UObject* WorldContextObject
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->StartNextActiveMethodDrillCase();
	}

	return FHyperTwistTrainingMethodDrillRunState();
}

FHyperTwistTrainingMethodDrillRunState UHyperTwistTrainingRuntimeLibrary::RevealActiveMethodDrillCase(
	UObject* WorldContextObject
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->RevealActiveMethodDrillCase();
	}

	return FHyperTwistTrainingMethodDrillRunState();
}

FHyperTwistTrainingMethodDrillRunState UHyperTwistTrainingRuntimeLibrary::RepeatActiveMethodDrillCase(
	UObject* WorldContextObject
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->RepeatActiveMethodDrillCase();
	}

	return FHyperTwistTrainingMethodDrillRunState();
}

FHyperTwistTrainingMethodDrillRunState UHyperTwistTrainingRuntimeLibrary::AdvanceActiveMethodDrillCase(
	UObject* WorldContextObject
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->AdvanceActiveMethodDrillCase();
	}

	return FHyperTwistTrainingMethodDrillRunState();
}

FHyperTwistTrainingMethodDrillRunState UHyperTwistTrainingRuntimeLibrary::FinishActiveMethodDrillRun(
	UObject* WorldContextObject,
	bool bAbortRun
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->FinishActiveMethodDrillRun(bAbortRun);
	}

	return FHyperTwistTrainingMethodDrillRunState();
}

FHyperTwistTrainingSession UHyperTwistTrainingRuntimeLibrary::CompleteActiveTrainingRun(
	UObject* WorldContextObject,
	bool bAbortSession
)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		return TrainingSubsystem->CompleteActiveRun(bAbortSession);
	}

	return FHyperTwistTrainingSession();
}

void UHyperTwistTrainingRuntimeLibrary::ClearActiveTrainingRun(UObject* WorldContextObject)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		TrainingSubsystem->ClearActiveRun();
	}
}

void UHyperTwistTrainingRuntimeLibrary::ClearActiveMethodDrillRun(UObject* WorldContextObject)
{
	if (UHyperTwistTrainingSubsystem* TrainingSubsystem = GetTrainingSubsystem(WorldContextObject))
	{
		TrainingSubsystem->ClearActiveMethodDrillRun();
	}
}
