Global functions

re.Hooks.PlaceVoid(
    "",
    "MPDisplayNarrationEventEntry",
    (_MPDisplayNarrationEventEntry x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _MPDisplayNarrationEventEntry(
    string text,
    float duration,
    Color color
);

re.Hooks.Place(
    "",
    "GetPlayer;GameInstance",
    (_GetPlayer x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.PlayerPuppet>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _GetPlayer(
    ScriptGameInstance gameInstance
);

re.Hooks.Place(
    "",
    "UnicodeStringLessThan",
    (_UnicodeStringLessThan x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _UnicodeStringLessThan(
    string str,
    string str2
);

re.Hooks.Place(
    "",
    "ModifierTypeToString;gameStatModifierType",
    (_ModifierTypeToString x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _ModifierTypeToString(
    game.StatModifierType type
);

re.Hooks.Place(
    "",
    "CreateForceRagdollNoPowerPoseEvent;CName",
    (_CreateForceRagdollNoPowerPoseEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ent.RagdollActivationRequestEvent>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _CreateForceRagdollNoPowerPoseEvent(
    CName debugSourceName
);

re.Hooks.Place(
    "",
    "PreviewConfig_DisableTurrets",
    (_PreviewConfig_DisableTurrets x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _PreviewConfig_DisableTurrets();

re.Hooks.PlaceVoid(
    "",
    "KillAll_NonExec;GameInstancePlayerPuppetString",
    (_KillAll_NonExec x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _KillAll_NonExec(
    ScriptGameInstance gameInstance,
    PlayerPuppet? player,
    string radiusStr
);

re.Hooks.Place(
    "",
    "BoolToString",
    (_BoolToString x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _BoolToString(
    bool value
);

re.Hooks.Place(
    "",
    "ExpF",
    (_ExpF x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _ExpF(
    float a
);

re.Hooks.Place(
    "",
    "AngleNormalize",
    (_AngleNormalize x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _AngleNormalize(
    float a
);

re.Hooks.Place(
    "",
    "TSQ_EnemyNPC;",
    (_TSQ_EnemyNPC x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.TargetSearchQuery>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _TSQ_EnemyNPC();

re.Hooks.PlaceVoid(
    "",
    "Debug_WeaponSpread_Set;GameInstanceBoolBoolInt32Int32",
    (_Debug_WeaponSpread_Set x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _Debug_WeaponSpread_Set(
    ScriptGameInstance gameInstance,
    bool useCircularDistribution,
    bool useEvenDistribution,
    int rowCount,
    int projectilesPerShot
);

re.Hooks.Place(
    "",
    "StrUpper",
    (_StrUpper x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _StrUpper(
    string str
);

re.Hooks.PlaceVoid(
    "",
    "IntToInt8",
    (_IntToInt8 x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _IntToInt8();

re.Hooks.PlaceVoid(
    "",
    "GetQueryMask",
    (_GetQueryMask x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _GetQueryMask();

re.Hooks.Place(
    "",
    "GetPlatformShortName",
    (_GetPlatformShortName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _GetPlatformShortName();

re.Hooks.Place(
    "",
    "EMPTY_ENTITY_ID;",
    (_EMPTY_ENTITY_ID x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ent.EntityID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _EMPTY_ENTITY_ID();

re.Hooks.PlaceVoid(
    "",
    "Trace",
    (_Trace x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _Trace();

re.Hooks.Place(
    "",
    "EmptyInventoryItemData;",
    (_EmptyInventoryItemData x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.InventoryItemData>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _EmptyInventoryItemData();

re.Hooks.Place(
    "",
    "ProcessCompareInt;EComparisonTypeInt32Int32",
    (_ProcessCompareInt x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _ProcessCompareInt(
    EComparisonType comparator,
    int valA,
    int valB
);

re.Hooks.PlaceVoid(
    "",
    "MPDisplayWarningMessage",
    (_MPDisplayWarningMessage x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _MPDisplayWarningMessage(
    float duration,
    string message,
    bool display
);

re.Hooks.Place(
    "",
    "CosF",
    (_CosF x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _CosF(
    float a
);

re.Hooks.PlaceVoid(
    "",
    "GetQueryMaskNONE",
    (_GetQueryMaskNONE x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _GetQueryMaskNONE();

re.Hooks.Place(
    "",
    "CeilF",
    (_CeilF x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _CeilF(
    float a
);

re.Hooks.Place(
    "",
    "GetLocalizedItemNameByString",
    (_GetLocalizedItemNameByString x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _GetLocalizedItemNameByString(
    CName hashKey
);

re.Hooks.Place(
    "",
    "ProcessCompare;EComparisonTypeFloatFloat",
    (_ProcessCompare x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _ProcessCompare(
    EComparisonType comparator,
    float valA,
    float valB
);

re.Hooks.Place(
    "",
    "RandRange",
    (_RandRange x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _RandRange(
    int min,
    int max
);

re.Hooks.Place(
    "",
    "GetLocalizedTextGanderDepened",
    (_GetLocalizedTextGanderDepened x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _GetLocalizedTextGanderDepened(
    string textKey,
    bool variantIsFemale
);

re.Hooks.Place(
    "",
    "GetGameInstance",
    (_GetGameInstance x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ScriptGameInstance>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _GetGameInstance();

re.Hooks.Place(
    "",
    "ReportFailure",
    (_ReportFailure x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _ReportFailure(
    string message
);

re.Hooks.PlaceVoid(
    "",
    "MPEquipWeapon",
    (_MPEquipWeapon x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _MPEquipWeapon(
    game.ItemID itemID,
    int QuickslotID
);

re.Hooks.Place(
    "",
    "StrBeforeFirst",
    (_StrBeforeFirst x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _StrBeforeFirst(
    string str,
    string match
);

re.Hooks.PlaceVoid(
    "",
    "AIInstantiateObject",
    (_AIInstantiateObject x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _AIInstantiateObject();

re.Hooks.PlaceVoid(
    "",
    "DebugDevices;GameInstanceBool",
    (_DebugDevices x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _DebugDevices(
    ScriptGameInstance gameInstance,
    bool shouldDebug
);

re.Hooks.Place(
    "",
    "CreateRagdollActivationRequestEvent;entragdollActivationRequestTypeCNameBoolBoolCName",
    (_CreateRagdollActivationRequestEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ent.RagdollActivationRequestEvent>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _CreateRagdollActivationRequestEvent(
    ent.ragdoll.ActivationRequestType activationType,
    CName filterDataOverride,
    bool applyPowerPose,
    bool applyMomentum,
    CName debugSourceName
);

re.Hooks.PlaceVoid(
    "",
    "InitializeScripts;",
    (_InitializeScripts x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _InitializeScripts();

re.Hooks.Place(
    "",
    "AngleApproach",
    (_AngleApproach x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _AngleApproach(
    float target,
    float cur,
    float step
);

re.Hooks.PlaceVoid(
    "",
    "RepResetTimeDilation",
    (_RepResetTimeDilation x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _RepResetTimeDilation();

re.Hooks.Place(
    "",
    "StringToFloat",
    (_StringToFloat x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _StringToFloat(
    string value,
    float defValue
);

re.Hooks.Place(
    "",
    "StrFindFirst",
    (_StrFindFirst x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _StrFindFirst(
    string str,
    string match
);

re.Hooks.PlaceVoid(
    "",
    "SendInputHintData;GameInstanceBoolscript_ref<InputHintData>CName",
    (_SendInputHintData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _SendInputHintData(
    ScriptGameInstance context,
    bool show,
    game.ui.InputHintData data,
    CName targetHintContainer
);

re.Hooks.Place(
    "",
    "ModF;FloatFloat",
    (_ModF x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _ModF(
    float a,
    float b
);

re.Hooks.Place(
    "",
    "StringToName",
    (_StringToName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _StringToName(
    string str
);

re.Hooks.Place(
    "",
    "CanLog;",
    (_CanLog x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _CanLog();

re.Hooks.Place(
    "",
    "GetLookAtStatus",
    (_GetLookAtStatus x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _GetLookAtStatus(
    anim.LookAtStatus status,
    float currentStatus
);

re.Hooks.Place(
    "",
    "ColorToHexString",
    (_ColorToHexString x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _ColorToHexString(
    Color value
);

re.Hooks.Place(
    "",
    "IsNodeRefDefined",
    (_IsNodeRefDefined x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _IsNodeRefDefined(
    NodeRef id
);

re.Hooks.Place(
    "",
    "ResolveNodeRefWithEntityID",
    (_ResolveNodeRefWithEntityID x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.world.GlobalNodeRef>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _ResolveNodeRefWithEntityID(
    NodeRef id,
    ent.EntityID context
);

re.Hooks.Place(
    "",
    "GetLocalizedTextByKey",
    (_GetLocalizedTextByKey x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _GetLocalizedTextByKey(
    CName hashKey
);

re.Hooks.Place(
    "",
    "RandRangeF",
    (_RandRangeF x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _RandRangeF(
    float min,
    float max
);

re.Hooks.Place(
    "",
    "CompareArrayNameContents",
    (_CompareArrayNameContents x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _CompareArrayNameContents(
    CName[] arr1,
    CName[] arr2
);

re.Hooks.Place(
    "",
    "GetActionAnimationSlideParams;AIActionSlideData_Record",
    (_GetActionAnimationSlideParams x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.ActionAnimationSlideParams>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _GetActionAnimationSlideParams(
    game.data.AIActionSlideData_Record? slideRecord
);

re.Hooks.Place(
    "",
    "IsServer",
    (_IsServer x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _IsServer();

re.Hooks.PlaceVoid(
    "",
    "LogChannel",
    (_LogChannel x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _LogChannel();

re.Hooks.Place(
    "",
    "StrCmp",
    (_StrCmp x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _StrCmp(
    string str,
    string with,
    int length,
    bool noCase
);

re.Hooks.Place(
    "",
    "IsLanguageVoicePackInstalled",
    (_IsLanguageVoicePackInstalled x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _IsLanguageVoicePackInstalled(
    CName language
);

re.Hooks.PlaceVoid(
    "",
    "Kill_NonExec;GameInstancePlayerPuppet",
    (_Kill_NonExec x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _Kill_NonExec(
    ScriptGameInstance gi,
    PlayerPuppet? player
);

re.Hooks.Place(
    "",
    "IsMultiplayer",
    (_IsMultiplayer x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _IsMultiplayer();

re.Hooks.PlaceVoid(
    "",
    "GetQueryMaskAll",
    (_GetQueryMaskAll x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _GetQueryMaskAll();

re.Hooks.Place(
    "",
    "BasicAvailabilityTest;ScriptableDeviceComponentPS",
    (_BasicAvailabilityTest x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _BasicAvailabilityTest(
    ScriptableDeviceComponentPS? device
);

re.Hooks.Place(
    "",
    "StrLeft",
    (_StrLeft x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _StrLeft(
    string str,
    int length
);

re.Hooks.PlaceVoid(
    "",
    "DebugBreak",
    (_DebugBreak x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _DebugBreak();

re.Hooks.PlaceVoid(
    "",
    "RequestInstallLanguagePackDialog",
    (_RequestInstallLanguagePackDialog x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _RequestInstallLanguagePackDialog(
    CName language
);

re.Hooks.PlaceVoid(
    "",
    "LogWarning",
    (_LogWarning x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _LogWarning();

re.Hooks.Place(
    "",
    "StrEndsWith",
    (_StrEndsWith x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _StrEndsWith(
    string str,
    string match
);

re.Hooks.PlaceVoid(
    "",
    "RepDecreaseGlobalTimeDilation",
    (_RepDecreaseGlobalTimeDilation x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _RepDecreaseGlobalTimeDilation();

re.Hooks.Place(
    "",
    "FloatToString",
    (_FloatToString x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _FloatToString(
    float value
);

re.Hooks.PlaceVoid(
    "",
    "PropagateDebugHitInformations",
    (_PropagateDebugHitInformations x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _PropagateDebugHitInformations(
    game.HitDetectionDebugFrameData[] hitDebugInfos
);

re.Hooks.Place(
    "",
    "IsFriendlyTowardsPlayer;GameObject",
    (_IsFriendlyTowardsPlayer x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _IsFriendlyTowardsPlayer(
    WeakHandle<game.Object> objectt
);

re.Hooks.Place(
    "",
    "TSF_All",
    (_TSF_All x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.TargetSearchFilter>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _TSF_All(
    game.targeting.SystemSearchFilterMaskValue mask
);

re.Hooks.Place(
    "",
    "RandPerlinNoiseF",
    (_RandPerlinNoiseF x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _RandPerlinNoiseF(
    int seed,
    float offset
);

re.Hooks.Place(
    "",
    "GetAllBlackboardDefs",
    (_GetAllBlackboardDefs x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.bb.AllScriptDefinitions>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _GetAllBlackboardDefs();

re.Hooks.Place(
    "",
    "GetLocalizedText",
    (_GetLocalizedText x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _GetLocalizedText(
    string textKey
);

re.Hooks.Place(
    "",
    "PocketRadioRestrictionCount;",
    (_PocketRadioRestrictionCount x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _PocketRadioRestrictionCount();

re.Hooks.Place(
    "",
    "LerpAngleF;FloatFloatFloat",
    (_LerpAngleF x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _LerpAngleF(
    float alpha,
    float a,
    float b
);

re.Hooks.PlaceVoid(
    "",
    "GameTimeIntervalContainsTime",
    (_GameTimeIntervalContainsTime x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _GameTimeIntervalContainsTime();

re.Hooks.Place(
    "",
    "StrLower",
    (_StrLower x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _StrLower(
    string str
);

re.Hooks.Place(
    "",
    "MaxF",
    (_MaxF x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _MaxF(
    float a,
    float b
);

re.Hooks.Place(
    "",
    "AbsF",
    (_AbsF x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _AbsF(
    float a
);

re.Hooks.Place(
    "",
    "TSF_Or",
    (_TSF_Or x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.TargetSearchFilter>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _TSF_Or(
    game.TargetSearchFilter tsf1,
    game.TargetSearchFilter tsf2,
    game.TargetSearchFilter tsf3,
    game.TargetSearchFilter tsf4
);

re.Hooks.Place(
    "",
    "IntToString",
    (_IntToString x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _IntToString(
    int value
);

re.Hooks.Place(
    "",
    "TSF_NPC;",
    (_TSF_NPC x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.TargetSearchFilter>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _TSF_NPC();

re.Hooks.Place(
    "",
    "GetDamageSystemLogFlags;",
    (_GetDamageSystemLogFlags x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Long>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _GetDamageSystemLogFlags();

re.Hooks.Place(
    "",
    "GetGameObjectFromEntityReference;EntityReferenceGameInstanceGameObject",
    (_GetGameObjectFromEntityReference x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _GetGameObjectFromEntityReference(
    game.EntityReference reference,
    ScriptGameInstance gameInstance,
    WeakHandle<game.Object> target
);

re.Hooks.Place(
    "",
    "IsStringNumber",
    (_IsStringNumber x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _IsStringNumber(
    string value
);

re.Hooks.Place(
    "",
    "GetInvalidDelayID;",
    (_GetInvalidDelayID x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.DelayID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _GetInvalidDelayID();

re.Hooks.PlaceVoid(
    "",
    "ApplyStatPoolModifier;GameInstancescript_ref<String>FloatFloatFloatFloatBoolgameStatPoolModificationTypes",
    (_ApplyStatPoolModifier x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _ApplyStatPoolModifier(
    ScriptGameInstance gi,
    string statPoolTypeString,
    float rangeBegin,
    float rangeEnd,
    float startDelay,
    float valuePerSec,
    bool delayOnChange,
    game.StatPoolModificationTypes statPoolModType
);

re.Hooks.Place(
    "",
    "RandDifferent",
    (_RandDifferent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _RandDifferent(
    int lastValue,
    int range
);

re.Hooks.Place(
    "",
    "GetItemTypeFromContext;ScriptExecutionContext",
    (_GetItemTypeFromContext x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _GetItemTypeFromContext(
    AIbehaviorScriptExecutionContext context
);

re.Hooks.Place(
    "",
    "UnicodeStringCompare",
    (_UnicodeStringCompare x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _UnicodeStringCompare(
    string str,
    string str2
);

re.Hooks.Place(
    "",
    "HalfPi;",
    (_HalfPi x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _HalfPi();

re.Hooks.Place(
    "",
    "TSF_EnemyNPC;",
    (_TSF_EnemyNPC x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.TargetSearchFilter>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _TSF_EnemyNPC();

re.Hooks.Place(
    "",
    "SqrtF",
    (_SqrtF x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _SqrtF(
    float a
);

re.Hooks.Place(
    "",
    "IntToEPreventionHeatStage;Int32",
    (_IntToEPreventionHeatStage x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EPreventionHeatStage>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _IntToEPreventionHeatStage(
    int index
);

re.Hooks.Place(
    "",
    "VectorToString;Vector4",
    (_VectorToString x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _VectorToString(
    Vector4 vec
);

re.Hooks.Place(
    "",
    "GetRadioStationLocalizedName",
    (_GetRadioStationLocalizedName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _GetRadioStationLocalizedName(
    uint radioStation
);

re.Hooks.Place(
    "",
    "ReinterpretIntAsFloat",
    (_ReinterpretIntAsFloat x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _ReinterpretIntAsFloat(
    int a
);

re.Hooks.Place(
    "",
    "MinF",
    (_MinF x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _MinF(
    float a,
    float b
);

re.Hooks.Place(
    "",
    "StrSplitFirst",
    (_StrSplitFirst x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _StrSplitFirst(
    string str,
    string divider,
    string left,
    string right
);

re.Hooks.Place(
    "",
    "BuildWidgetPath",
    (_BuildWidgetPath x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ink.WidgetPath>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _BuildWidgetPath(
    CName[] names
);

re.Hooks.Place(
    "",
    "RandF",
    (_RandF x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _RandF();

re.Hooks.Place(
    "",
    "ToTelemetryInventoryItem;script_ref<InventoryItemData>",
    (_ToTelemetryInventoryItem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.TelemetryInventoryItem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _ToTelemetryInventoryItem(
    game.InventoryItemData inventoryItemData
);

re.Hooks.PlaceVoid(
    "",
    "FTLogWarning",
    (_FTLogWarning x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _FTLogWarning(
    string value
);

re.Hooks.Place(
    "",
    "TSQ_ALL;",
    (_TSQ_ALL x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.TargetSearchQuery>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _TSQ_ALL();

re.Hooks.Place(
    "",
    "GetFact;GameInstanceCName",
    (_GetFact x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _GetFact(
    ScriptGameInstance game,
    CName factName
);

re.Hooks.Place(
    "",
    "ToInventoryItemData;GameObjectItemID",
    (_ToInventoryItemData x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.InventoryItemData>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _ToInventoryItemData(
    WeakHandle<game.Object> owner,
    game.ItemID itemID
);

re.Hooks.Place(
    "",
    "LogF",
    (_LogF x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _LogF(
    float a
);

re.Hooks.PlaceVoid(
    "",
    "GetFixedEntityIdsFromSpawnerEntityID",
    (_GetFixedEntityIdsFromSpawnerEntityID x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _GetFixedEntityIdsFromSpawnerEntityID(
    ent.EntityID entityID,
    CName[] communityEntryNames,
    ScriptGameInstance gameInstance,
    List<ent.EntityID> outEntityIds
);

re.Hooks.Place(
    "",
    "NoTrailZeros",
    (_NoTrailZeros x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _NoTrailZeros(
    string str
);

re.Hooks.Place(
    "",
    "RandNoiseF",
    (_RandNoiseF x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _RandNoiseF(
    int seed,
    float max,
    float min
);

re.Hooks.PlaceVoid(
    "",
    "RefreshSettings",
    (_RefreshSettings x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _RefreshSettings();

re.Hooks.Place(
    "",
    "TSQ_NPC;",
    (_TSQ_NPC x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.TargetSearchQuery>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _TSQ_NPC();

re.Hooks.Place(
    "",
    "StrChar",
    (_StrChar x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _StrChar(
    int i
);

re.Hooks.Place(
    "",
    "StrSplitLast",
    (_StrSplitLast x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _StrSplitLast(
    string str,
    string divider,
    string left,
    string right
);

re.Hooks.Place(
    "",
    "GetInvalidVisionBlockerID;",
    (_GetInvalidVisionBlockerID x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Uint>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _GetInvalidVisionBlockerID();

re.Hooks.PlaceVoid(
    "",
    "EquipPickableItemOnClient",
    (_EquipPickableItemOnClient x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _EquipPickableItemOnClient(
    game.ItemID itemID,
    int quickSlotID
);

re.Hooks.Place(
    "",
    "Max",
    (_Max x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _Max(
    int a,
    int b
);

re.Hooks.Place(
    "",
    "StatsEffectsEnumToTDBID",
    (_StatsEffectsEnumToTDBID x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.TDBID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _StatsEffectsEnumToTDBID(
    int statsEffectsEnum
);

re.Hooks.Place(
    "",
    "RoundTo;FloatInt32",
    (_RoundTo x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _RoundTo(
    float f,
    int decimall
);

re.Hooks.Place(
    "",
    "ToTelemetryEnemy;GameObject",
    (_ToTelemetryEnemy x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.TelemetryEnemy>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _ToTelemetryEnemy(
    WeakHandle<game.Object> target
);

re.Hooks.Place(
    "",
    "AtanF",
    (_AtanF x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _AtanF(
    float a,
    float b
);

re.Hooks.PlaceVoid(
    "",
    "ServerAddPingTarget",
    (_ServerAddPingTarget x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _ServerAddPingTarget(
    game.PingEntry pingEntry
);

re.Hooks.PlaceVoid(
    "",
    "ParseNodeRef",
    (_ParseNodeRef x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _ParseNodeRef();

re.Hooks.PlaceVoid(
    "",
    "DebugGiveHotkeys;GameInstance",
    (_DebugGiveHotkeys x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _DebugGiveHotkeys(
    ScriptGameInstance gameInstance
);

re.Hooks.PlaceVoid(
    "",
    "Rand",
    (_Rand x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _Rand();

re.Hooks.Place(
    "",
    "GetIgnoredVisionBlockerTypes;GameInstanceStatsObjectID",
    (_GetIgnoredVisionBlockerTypes x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.sense.VisionBlockerTypeFlags>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _GetIgnoredVisionBlockerTypes(
    ScriptGameInstance game,
    game.StatsObjectID objID
);

re.Hooks.Place(
    "",
    "Pi;",
    (_Pi x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _Pi();

re.Hooks.Place(
    "",
    "EnumGetMax",
    (_EnumGetMax x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Long>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _EnumGetMax(
    CName type
);

re.Hooks.PlaceVoid(
    "",
    "GetGameObjectsFromSpawnerEntityID",
    (_GetGameObjectsFromSpawnerEntityID x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _GetGameObjectsFromSpawnerEntityID(
    ent.EntityID entityID,
    CName[] communityEntryNames,
    ScriptGameInstance gameInstance,
    game.Object[] outGameObjects
);

re.Hooks.PlaceVoid(
    "",
    "ActivateTickForTransformAnimator",
    (_ActivateTickForTransformAnimator x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _ActivateTickForTransformAnimator(
    ent.EntityID entityID,
    CName componentName,
    bool activate
);

re.Hooks.Place(
    "",
    "Abs",
    (_Abs x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _Abs(
    int a
);

re.Hooks.PlaceVoid(
    "",
    "MPDisplayOnscreenMessage",
    (_MPDisplayOnscreenMessage x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _MPDisplayOnscreenMessage(
    float duration,
    string message,
    bool display
);

re.Hooks.Place(
    "",
    "SelectWidgets;inkWidgetinkSelectionRuleString",
    (_SelectWidgets x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ink.WidgetsSet>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _SelectWidgets(
    ink.Widget? widget,
    ink.SelectionRule selectionRule,
    string param
);

re.Hooks.Place(
    "",
    "TSF_Any",
    (_TSF_Any x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.TargetSearchFilter>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _TSF_Any(
    game.targeting.SystemSearchFilterMaskValue mask
);

re.Hooks.Place(
    "",
    "GetLookAtLimitDistanceValue",
    (_GetLookAtLimitDistanceValue x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _GetLookAtLimitDistanceValue(
    anim.LookAtLimitDistanceType limitType
);

re.Hooks.Place(
    "",
    "EnumValueFromName",
    (_EnumValueFromName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Long>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _EnumValueFromName(
    CName enumName,
    CName enumValue
);

re.Hooks.Place(
    "",
    "RoundF",
    (_RoundF x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _RoundF(
    float a
);

re.Hooks.Place(
    "",
    "GetOppositeRotation180;EulerAngles",
    (_GetOppositeRotation180 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EulerAngles>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _GetOppositeRotation180(
    EulerAngles rot
);

re.Hooks.PlaceVoid(
    "",
    "Log",
    (_Log x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _Log();

re.Hooks.Place(
    "",
    "GetAnimOptionsInfiniteLoop;inkanimLoopType",
    (_GetAnimOptionsInfiniteLoop x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ink.anim.PlaybackOptions>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _GetAnimOptionsInfiniteLoop(
    ink.anim.LoopType loopType
);

re.Hooks.PlaceVoid(
    "",
    "UseProfiler",
    (_UseProfiler x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _UseProfiler();

re.Hooks.Place(
    "",
    "CalcSeed",
    (_CalcSeed x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _CalcSeed(
    IScriptable? objectt
);

re.Hooks.Place(
    "",
    "GetLookAtLimitDegreesValue",
    (_GetLookAtLimitDegreesValue x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _GetLookAtLimitDegreesValue(
    anim.LookAtLimitDegreesType limitType
);

re.Hooks.Place(
    "",
    "StrMid",
    (_StrMid x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _StrMid(
    string str,
    int first,
    int length
);

re.Hooks.Place(
    "",
    "Min",
    (_Min x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _Min(
    int a,
    int b
);

re.Hooks.PlaceVoid(
    "",
    "PvdClientConnect",
    (_PvdClientConnect x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _PvdClientConnect(
    string server
);

re.Hooks.PlaceVoid(
    "",
    "ProgressMultipleAchievementsImpl;GameInstanceStringStringStringString",
    (_ProgressMultipleAchievementsImpl x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _ProgressMultipleAchievementsImpl(
    ScriptGameInstance gameInstance,
    string achievementId,
    string achievementCount,
    string baseProgressString,
    string intervalString
);

re.Hooks.Place(
    "",
    "IsHostileTowardsPlayer;GameObject",
    (_IsHostileTowardsPlayer x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _IsHostileTowardsPlayer(
    WeakHandle<game.Object> objectt
);

re.Hooks.Place(
    "",
    "IsClient",
    (_IsClient x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _IsClient();

re.Hooks.Place(
    "",
    "StrBeforeLast",
    (_StrBeforeLast x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _StrBeforeLast(
    string str,
    string match
);

re.Hooks.Place(
    "",
    "GetScreenPosition",
    (_GetScreenPosition x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.RectF>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _GetScreenPosition(
    WeakHandle<ink.Widget> widget
);

re.Hooks.Place(
    "",
    "GetImmortality;GameObjectgameGodModeType",
    (_GetImmortality x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _GetImmortality(
    game.Object? gameObject,
    game.GodModeType type
);

re.Hooks.PlaceVoid(
    "",
    "IntToUint64",
    (_IntToUint64 x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _IntToUint64();

re.Hooks.Place(
    "",
    "TSF_Not",
    (_TSF_Not x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.TargetSearchFilter>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _TSF_Not(
    game.targeting.SystemSearchFilterMaskValue mask
);

re.Hooks.Place(
    "",
    "SqrF",
    (_SqrF x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _SqrF(
    float a
);

re.Hooks.Place(
    "",
    "AngleNormalize180",
    (_AngleNormalize180 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _AngleNormalize180(
    float a
);

re.Hooks.PlaceVoid(
    "",
    "RepTeleportPlayer",
    (_RepTeleportPlayer x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _RepTeleportPlayer(
    WeakHandle<game.Object> player,
    Vector3 pos,
    EulerAngles rot
);

re.Hooks.Place(
    "",
    "StrLen",
    (_StrLen x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _StrLen(
    string str
);

re.Hooks.Place(
    "",
    "IsStringValid",
    (_IsStringValid x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _IsStringValid(
    string n
);

re.Hooks.PlaceVoid(
    "",
    "ArraySortInts",
    (_ArraySortInts x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _ArraySortInts();

re.Hooks.Place(
    "",
    "EnumValueToString",
    (_EnumValueToString x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _EnumValueToString(
    string enumStr,
    long enumValue
);

re.Hooks.Place(
    "",
    "ResolveNodeRef",
    (_ResolveNodeRef x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.world.GlobalNodeRef>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _ResolveNodeRef(
    NodeRef id,
    world.GlobalNodeRef context
);

re.Hooks.PlaceVoid(
    "",
    "RepDecreasePlayerTimeDilation",
    (_RepDecreasePlayerTimeDilation x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _RepDecreasePlayerTimeDilation();

re.Hooks.PlaceVoid(
    "",
    "Uint64ToString",
    (_Uint64ToString x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _Uint64ToString();

re.Hooks.PlaceVoid(
    "",
    "MPChangeMessageBoxValues",
    (_MPChangeMessageBoxValues x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _MPChangeMessageBoxValues(
    game.PopupData data,
    game.PopupSettings settings,
    bool visible
);

re.Hooks.Place(
    "",
    "ProportionalClampF;FloatFloatFloatFloatFloat",
    (_ProportionalClampF x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _ProportionalClampF(
    float inMin,
    float inMax,
    float v,
    float outMin,
    float outMax
);

re.Hooks.Place(
    "",
    "FloatToStringPrec",
    (_FloatToStringPrec x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _FloatToStringPrec(
    float value,
    int precision
);

re.Hooks.Place(
    "",
    "EnumGetMin",
    (_EnumGetMin x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Long>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _EnumGetMin(
    CName type
);

re.Hooks.Place(
    "",
    "StringToBool",
    (_StringToBool x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _StringToBool(
    string s
);

re.Hooks.Place(
    "",
    "IsNameValid",
    (_IsNameValid x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _IsNameValid(
    CName n
);

re.Hooks.Place(
    "",
    "StrBeginsWith",
    (_StrBeginsWith x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _StrBeginsWith(
    string str,
    string match
);

re.Hooks.PlaceVoid(
    "",
    "Uint64ToInt",
    (_Uint64ToInt x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _Uint64ToInt();

re.Hooks.Place(
    "",
    "SpaceFill;StringInt32ESpaceFillModeString",
    (_SpaceFill x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _SpaceFill(
    string str,
    int length,
    ESpaceFillMode mode,
    string fillChar
);

re.Hooks.Place(
    "",
    "GetFilledUV;Vector2Vector2",
    (_GetFilledUV x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.RectF>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _GetFilledUV(
    Vector2 containerSize,
    Vector2 contentSize
);

re.Hooks.Place(
    "",
    "CreateRagdollApplyImpulseEvent;Vector4Vector4Float",
    (_CreateRagdollApplyImpulseEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ent.RagdollApplyImpulseEvent>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _CreateRagdollApplyImpulseEvent(
    Vector4 worldPos,
    Vector4 imuplseVal,
    float influenceRadius
);

re.Hooks.Place(
    "",
    "TanF",
    (_TanF x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _TanF(
    float a
);

re.Hooks.Place(
    "",
    "UnicodeStringEqual",
    (_UnicodeStringEqual x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _UnicodeStringEqual(
    string str,
    string str2
);

re.Hooks.Place(
    "",
    "GetDisplaySize;Vector2Vector2",
    (_GetDisplaySize x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector2>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _GetDisplaySize(
    Vector2 wrapperSize,
    Vector2 frameSize
);

re.Hooks.PlaceVoid(
    "",
    "SortHandleWithValueArray",
    (_SortHandleWithValueArray x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _SortHandleWithValueArray(
    script.OptimizationsHandleWithValue[] arr
);

re.Hooks.Place(
    "",
    "StrReplace",
    (_StrReplace x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _StrReplace(
    string str,
    string match,
    string with
);

re.Hooks.Place(
    "",
    "IsEntityInInteriorArea",
    (_IsEntityInInteriorArea x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _IsEntityInInteriorArea(
    WeakHandle<ent.Entity> entity
);

re.Hooks.Place(
    "",
    "Compare;ECompareOpInt32Int32",
    (_Compare x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _Compare(
    ECompareOp comparator,
    int val1,
    int val2
);

re.Hooks.Place(
    "",
    "IsFinal",
    (_IsFinal x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _IsFinal();

re.Hooks.PlaceVoid(
    "",
    "DumpClassHierarchy",
    (_DumpClassHierarchy x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _DumpClassHierarchy();

re.Hooks.PlaceVoid(
    "",
    "AIReleaseObject",
    (_AIReleaseObject x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _AIReleaseObject();

re.Hooks.Place(
    "",
    "StrFrontToLower",
    (_StrFrontToLower x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _StrFrontToLower(
    string str
);

re.Hooks.Place(
    "",
    "PowF",
    (_PowF x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _PowF(
    float a,
    float x
);

re.Hooks.Place(
    "",
    "AsinF",
    (_AsinF x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _AsinF(
    float a
);

re.Hooks.Place(
    "",
    "FloorF",
    (_FloorF x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _FloorF(
    float a
);

re.Hooks.PlaceVoid(
    "",
    "LogChannelWarning",
    (_LogChannelWarning x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _LogChannelWarning();

re.Hooks.Place(
    "",
    "StringToInt",
    (_StringToInt x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _StringToInt(
    string value,
    int defValue
);

re.Hooks.Place(
    "",
    "SinF",
    (_SinF x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _SinF(
    float a
);

re.Hooks.Place(
    "",
    "FloatIsEqual;FloatFloat",
    (_FloatIsEqual x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _FloatIsEqual(
    float f,
    float to
);

re.Hooks.Place(
    "",
    "UnicodeStringLessThanEqual",
    (_UnicodeStringLessThanEqual x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _UnicodeStringLessThanEqual(
    string str,
    string str2
);

re.Hooks.Place(
    "",
    "StringToHex",
    (_StringToHex x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _StringToHex(
    string str,
    uint lineLength
);

re.Hooks.Place(
    "",
    "IsFastForwardPossibleInVehicle;StateContextStateGameScriptInterface",
    (_IsFastForwardPossibleInVehicle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _IsFastForwardPossibleInVehicle(
    game.stateMachine.StateContextScript? stateContext,
    game.stateMachine.GameScriptInterface? scriptInterface
);

re.Hooks.Place(
    "",
    "UnicodeLength",
    (_UnicodeLength x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _UnicodeLength(
    string str
);

re.Hooks.Place(
    "",
    "StrReplaceAll",
    (_StrReplaceAll x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _StrReplaceAll(
    string str,
    string match,
    string with
);

re.Hooks.Place(
    "",
    "EnumValueToName",
    (_EnumValueToName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _EnumValueToName(
    CName enumName,
    long enumValue
);

re.Hooks.PlaceVoid(
    "",
    "LoadResourceAsync",
    (_LoadResourceAsync x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _LoadResourceAsync();

re.Hooks.Place(
    "",
    "ClampF",
    (_ClampF x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _ClampF(
    float v,
    float min,
    float max
);

re.Hooks.PlaceVoid(
    "",
    "ArmouryEquipWeapon",
    (_ArmouryEquipWeapon x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _ArmouryEquipWeapon(
    game.ItemID itemID,
    int QuickslotID
);

re.Hooks.Place(
    "",
    "Rad2Deg",
    (_Rad2Deg x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _Rad2Deg(
    float rad
);

re.Hooks.Place(
    "",
    "LocKeyToString",
    (_LocKeyToString x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _LocKeyToString(
    CName hashKey
);

re.Hooks.PlaceVoid(
    "",
    "LogError",
    (_LogError x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _LogError();

re.Hooks.Place(
    "",
    "SetFactValue;GameInstanceCNameInt32",
    (_SetFactValue x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _SetFactValue(
    ScriptGameInstance game,
    CName factName,
    int factCount
);

re.Hooks.PlaceVoid(
    "",
    "RepIncreasePlayerTimeDilation",
    (_RepIncreasePlayerTimeDilation x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _RepIncreasePlayerTimeDilation();

re.Hooks.Place(
    "",
    "StrContains",
    (_StrContains x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _StrContains(
    string str,
    string subStr
);

re.Hooks.Place(
    "",
    "GetMainPlayer;GameInstance",
    (_GetMainPlayer x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.PlayerPuppet>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _GetMainPlayer(
    ScriptGameInstance gameInstance
);

re.Hooks.Place(
    "",
    "CreatePersistentID",
    (_CreatePersistentID x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.PersistentID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _CreatePersistentID(
    ent.EntityID entityID,
    CName componentName
);

re.Hooks.PlaceVoid(
    "",
    "RepIncreaseGlobalTimeDilation",
    (_RepIncreaseGlobalTimeDilation x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _RepIncreaseGlobalTimeDilation();

re.Hooks.Place(
    "",
    "EnumValueFromString",
    (_EnumValueFromString x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Long>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _EnumValueFromString(
    string enumStr,
    string enumValue
);

re.Hooks.Place(
    "",
    "Deg2Rad",
    (_Deg2Rad x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _Deg2Rad(
    float deg
);

re.Hooks.PlaceVoid(
    "",
    "LogChannelError",
    (_LogChannelError x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _LogChannelError();

re.Hooks.PlaceVoid(
    "",
    "RepToggleGamePause",
    (_RepToggleGamePause x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _RepToggleGamePause();

re.Hooks.PlaceVoid(
    "",
    "PreloadGameEffectAttackResources;Attack_GameEffect_RecordEffectSystem",
    (_PreloadGameEffectAttackResources x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _PreloadGameEffectAttackResources(
    game.data.Attack_GameEffect_Record? attackRecord,
    game.EffectSystem? effectSystem
);

re.Hooks.Place(
    "",
    "GetCaptionTagsFromArray;script_ref<array<InteractionChoiceCaptionPart>>",
    (_GetCaptionTagsFromArray x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _GetCaptionTagsFromArray(
    game.interactions.ChoiceCaptionPart[] argList
);

re.Hooks.Place(
    "",
    "ToTelemetryDamage;gameDamageReceivedEvent",
    (_ToTelemetryDamage x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.TelemetryDamage>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _ToTelemetryDamage(
    game.events.DamageReceivedEvent? evt
);

re.Hooks.Place(
    "",
    "AcosF",
    (_AcosF x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _AcosF(
    float a
);

re.Hooks.PlaceVoid(
    "",
    "FTLogError",
    (_FTLogError x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _FTLogError(
    string value
);

re.Hooks.Place(
    "",
    "AddFact;GameInstanceCNameInt32",
    (_AddFact x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _AddFact(
    ScriptGameInstance game,
    CName factName,
    int factCount
);

re.Hooks.Place(
    "",
    "IsHost",
    (_IsHost x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _IsHost();

re.Hooks.PlaceVoid(
    "",
    "MPReplicateComboAttack",
    (_MPReplicateComboAttack x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _MPReplicateComboAttack(
    Vector4 position,
    WeakHandle<game.Object> instigator
);

re.Hooks.Place(
    "",
    "StrFindLast",
    (_StrFindLast x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _StrFindLast(
    string str,
    string match
);

re.Hooks.Place(
    "",
    "AreDebugContextsEnabled",
    (_AreDebugContextsEnabled x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _AreDebugContextsEnabled();

re.Hooks.Place(
    "",
    "CreateDisableRagdollEvent;CName",
    (_CreateDisableRagdollEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ent.RagdollDisableEvent>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _CreateDisableRagdollEvent(
    CName debugSourceName
);

re.Hooks.Place(
    "",
    "GOGRewardSystemErrorToDisplayString",
    (_GOGRewardSystemErrorToDisplayString x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _GOGRewardSystemErrorToDisplayString(
    game.OnlineSystemErrors error
);

re.Hooks.Place(
    "",
    "Clamp",
    (_Clamp x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _Clamp(
    int v,
    int min,
    int max
);

re.Hooks.Place(
    "",
    "SgnF;Float",
    (_SgnF x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _SgnF(
    float a
);

re.Hooks.PlaceVoid(
    "",
    "SwitchPlayerImmortalityMode;GameInstancegamecheatsystemFlag",
    (_SwitchPlayerImmortalityMode x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _SwitchPlayerImmortalityMode(
    ScriptGameInstance gi,
    game.cheatsystem.Flag cheat
);

re.Hooks.Place(
    "",
    "TSF_Quickhackable;",
    (_TSF_Quickhackable x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.TargetSearchFilter>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _TSF_Quickhackable();

re.Hooks.Place(
    "",
    "GetLookAtTransitionSpeed",
    (_GetLookAtTransitionSpeed x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _GetLookAtTransitionSpeed(
    anim.LookAtStyle style
);

re.Hooks.Place(
    "",
    "StrAfterLast",
    (_StrAfterLast x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _StrAfterLast(
    string str,
    string match
);

re.Hooks.PlaceVoid(
    "",
    "DebugNPCs_NonExec;GameInstanceStringStringString",
    (_DebugNPCs_NonExec x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _DebugNPCs_NonExec(
    ScriptGameInstance gi,
    string durationStr,
    string radiusStr,
    string moveWithPlayerStr
);

re.Hooks.Place(
    "",
    "CreateForceRagdollWithCustomFilterDataEvent;CNameCName",
    (_CreateForceRagdollWithCustomFilterDataEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ent.RagdollActivationRequestEvent>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _CreateForceRagdollWithCustomFilterDataEvent(
    CName customFilterData,
    CName debugSourceName
);

re.Hooks.Place(
    "",
    "TSF_And",
    (_TSF_And x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.TargetSearchFilter>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _TSF_And(
    game.TargetSearchFilter tsf1,
    game.TargetSearchFilter tsf2,
    game.TargetSearchFilter tsf3,
    game.TargetSearchFilter tsf4
);

re.Hooks.Place(
    "",
    "CreateEntityReference",
    (_CreateEntityReference x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.EntityReference>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _CreateEntityReference(
    string nodeRefString,
    CName[] communityEntryNames
);

re.Hooks.Place(
    "",
    "RoundFEx",
    (_RoundFEx x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _RoundFEx(
    float a
);

re.Hooks.Place(
    "",
    "GetRadioStationCurrentTrackName",
    (_GetRadioStationCurrentTrackName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _GetRadioStationCurrentTrackName(
    CName radioReceiverStationName
);

re.Hooks.PlaceVoid(
    "",
    "AT_AddATID",
    (_AT_AddATID x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _AT_AddATID(
    WeakHandle<ink.Widget> widget,
    string atid
);

re.Hooks.PlaceVoid(
    "",
    "ReleaseGameEffectAttackResources;Attack_GameEffect_RecordEffectSystem",
    (_ReleaseGameEffectAttackResources x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _ReleaseGameEffectAttackResources(
    game.data.Attack_GameEffect_Record? attackRecord,
    game.EffectSystem? effectSystem
);

re.Hooks.PlaceVoid(
    "",
    "Int8ToInt",
    (_Int8ToInt x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _Int8ToInt();

re.Hooks.Place(
    "",
    "AngleDistance",
    (_AngleDistance x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _AngleDistance(
    float target,
    float current
);

re.Hooks.PlaceVoid(
    "",
    "PvdFileDumpConnect",
    (_PvdFileDumpConnect x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _PvdFileDumpConnect(
    string filePath
);

re.Hooks.Place(
    "",
    "GetLocalizedItemNameByCName",
    (_GetLocalizedItemNameByCName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _GetLocalizedItemNameByCName(
    CName hashKey
);

re.Hooks.Place(
    "",
    "IsNoInputIconsModeEnabled",
    (_IsNoInputIconsModeEnabled x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _IsNoInputIconsModeEnabled();

re.Hooks.Place(
    "",
    "NameToString",
    (_NameToString x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _NameToString(
    CName n
);

re.Hooks.Place(
    "",
    "ToTelemetryDamageDealt;gameDamageReceivedEventgameTelemetryDamageSituationFloatFloat",
    (_ToTelemetryDamageDealt x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.TelemetryDamageDealt>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _ToTelemetryDamageDealt(
    game.events.DamageReceivedEvent? evt,
    game.TelemetryDamageSituation situation,
    float distance,
    float time
);

re.Hooks.Place(
    "",
    "ToTelemetryDamage;gameTargetDamageEvent",
    (_ToTelemetryDamage2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.TelemetryDamage>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _ToTelemetryDamage2(
    game.events.TargetDamageEvent? evt
);

re.Hooks.Place(
    "",
    "RoundMath;Float",
    (_RoundMath x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _RoundMath(
    float f
);

re.Hooks.PlaceVoid(
    "",
    "AIInstantiatePrototype",
    (_AIInstantiatePrototype x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _AIInstantiatePrototype();

re.Hooks.Place(
    "",
    "EnsureFailure",
    (_EnsureFailure x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _EnsureFailure(
    string message
);

re.Hooks.Place(
    "",
    "GetLookAtLimits",
    (_GetLookAtLimits x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.anim.AnimLookAtLimits>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _GetLookAtLimits(
    anim.LookAtLimitDegreesType softLimitDegreesType,
    anim.LookAtLimitDegreesType hardLimitDegreesType,
    anim.LookAtLimitDistanceType hardLimitDistanceType,
    anim.LookAtLimitDegreesType backLimitDegreesType
);

re.Hooks.Place(
    "",
    "GetPSGeneratorVersion;",
    (_GetPSGeneratorVersion x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _GetPSGeneratorVersion();

re.Hooks.Place(
    "",
    "IsSingleplayer",
    (_IsSingleplayer x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _IsSingleplayer();

re.Hooks.Place(
    "",
    "StrAfterFirst",
    (_StrAfterFirst x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _StrAfterFirst(
    string str,
    string match
);

re.Hooks.Place(
    "",
    "SpawnVirtualPS;GameInstanceEntityIDCNameCName",
    (_SpawnVirtualPS x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.PersistentState>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _SpawnVirtualPS(
    ScriptGameInstance game,
    ent.EntityID entityID,
    CName componentName,
    CName psClassName
);

re.Hooks.PlaceVoid(
    "",
    "GetFixedEntityIdsFromEntityReference",
    (_GetFixedEntityIdsFromEntityReference x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _GetFixedEntityIdsFromEntityReference(
    game.EntityReference puppetRef,
    ScriptGameInstance gameInstance,
    List<ent.EntityID> outEntityIds
);

re.Hooks.Place(
    "",
    "CreateForceRagdollEvent;CName",
    (_CreateForceRagdollEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ent.RagdollActivationRequestEvent>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _CreateForceRagdollEvent(
    CName debugSourceName
);

re.Hooks.PlaceVoid(
    "",
    "SetDefaultStatPoolModifiers;GameInstancescript_ref<String>gameStatPoolModificationTypes",
    (_SetDefaultStatPoolModifiers x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _SetDefaultStatPoolModifiers(
    ScriptGameInstance gi,
    string statPoolTypeString,
    game.StatPoolModificationTypes statPoolModType
);

re.Hooks.PlaceVoid(
    "",
    "ArraySortStrings",
    (_ArraySortStrings x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _ArraySortStrings();

re.Hooks.Place(
    "",
    "IsEP1",
    (_IsEP1 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _IsEP1();

re.Hooks.Place(
    "",
    "NoScreenMessage;",
    (_NoScreenMessage x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.SimpleScreenMessage>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _NoScreenMessage();

re.Hooks.Place(
    "",
    "GetLocalizedTextGanderDepenedByKey",
    (_GetLocalizedTextGanderDepenedByKey x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _GetLocalizedTextGanderDepenedByKey(
    CName hashKey,
    bool variantIsFemale
);

re.Hooks.Place(
    "",
    "GetPlayerObject;GameInstance",
    (_GetPlayerObject x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.GameObject>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _GetPlayerObject(
    ScriptGameInstance gameInstance
);

re.Hooks.Place(
    "",
    "StrFrontToUpper",
    (_StrFrontToUpper x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _StrFrontToUpper(
    string str
);

re.Hooks.Place(
    "",
    "ToTelemetryDamageDealt;gameTargetDamageEventgameTelemetryDamageSituationFloatFloat",
    (_ToTelemetryDamageDealt2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.TelemetryDamageDealt>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _ToTelemetryDamageDealt2(
    game.events.TargetDamageEvent? evt,
    game.TelemetryDamageSituation situation,
    float distance,
    float time
);

re.Hooks.PlaceVoid(
    "",
    "RepEnableCheatOnPlayer",
    (_RepEnableCheatOnPlayer x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _RepEnableCheatOnPlayer(
    WeakHandle<game.Object> player,
    uint cheat,
    bool enable
);

re.Hooks.Place(
    "",
    "StringToUint64",
    (_StringToUint64 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Ulong>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _StringToUint64(
    string value,
    ulong defValue
);

re.Hooks.Place(
    "",
    "CanChangeAttitudeRelationFor;CName",
    (_CanChangeAttitudeRelationFor x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _CanChangeAttitudeRelationFor(
    CName groupName
);

re.Hooks.Place(
    "",
    "StrRight",
    (_StrRight x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _StrRight(
    string str,
    int length
);

re.Hooks.PlaceVoid(
    "",
    "TraceToString",
    (_TraceToString x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _TraceToString();

re.Hooks.Place(
    "",
    "LerpF",
    (_LerpF x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _LerpF(
    float alpha,
    float a,
    float b,
    bool clamp
);

re.Hooks.PlaceVoid(
    "",
    "FTLog",
    (_FTLog x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _FTLog(
    string value
);

re.Hooks.Place(
    "",
    "CompareF;ECompareOpFloatFloat",
    (_CompareF x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _CompareF(
    ECompareOp comparator,
    float val1,
    float val2
);

re.Hooks.PlaceVoid(
    "",
    "ArraySortFloats",
    (_ArraySortFloats x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _ArraySortFloats();

re.Hooks.PlaceVoid(
    "",
    "LoadResource",
    (_LoadResource x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct _LoadResource();

re.Hooks.Place(
    "",
    "ToTelemetryDamage;AttackData",
    (_ToTelemetryDamage3 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.TelemetryDamage>();
    }
);

[Msgpack.Gen]
public readonly partial record struct _ToTelemetryDamage3(
    game.damage.AttackData? attackData
);