class

Device

51 properties
430 functions
11 derived classes

Extends game.DeviceBase game.Object ent.GameEntity ent.Entity IScriptable ISerializable

Derived

BaseDestructibleDevice, DropPointModule, ElectricLight, GlitchedTurret, InteractiveDevice, InteractiveSign, InvisibleSceneStash, ProximityDetector, SimpleOnTurnOnPlayEffectDevice, TrafficLight

Show 1 more of 11 derived classes

VirtualMasterDevice

Properties

Property	Type	Offset
`controller`	`ScriptableDeviceComponent?`	`0xF0`	scripted
`wasVisible`	`bool`	`0x100`	scripted
`isVisible`	`bool`	`0x101`	scripted
`controllerTypeName`	`CName`	`0x108`	scripted
`deviceState`	`EDeviceStatus`	`0x110`	scripted
`uiComponent`	`WeakHandle<IWorldWidgetComponent>`	`0x118`	scripted
`screenDefinition`	`SUIScreenDefinition`	`0x128`	scripted
`isUIdirty`	`bool`	`0x138`	scripted
`onInputHintManagerInitializedChangedCallback`	`red.CallbackObject?`	`0x140`	scripted
`personalLinkComponent`	`work.WorkspotResourceComponent?`	`0x150`	scripted
`durabilityType`	`EDeviceDurabilityType`	`0x160`	scripted
`disassemblableComponent`	`DisassemblableComponent?`	`0x168`	scripted
`localization`	`ent.LocalizationStringComponent?`	`0x178`	scripted
`IKslotComponent`	`ent.SlotComponent?`	`0x188`	scripted
`slotComponent`	`ent.SlotComponent?`	`0x198`	scripted
`isInitialized`	`bool`	`0x1A8`	scripted
`isInsideLogicArea`	`bool`	`0x1A9`	scripted
`cameraComponent`	`game.CameraComponent?`	`0x1B0`	scripted
`cameraZoomComponent`	`game.CameraComponent?`	`0x1C0`	scripted
`cameraZoomActive`	`bool`	`0x1D0`	scripted
`ToggleZoomInteractionWorkspot`	`work.WorkspotResourceComponent?`	`0x1D8`	scripted
`ZoomUIListenerID`	`red.CallbackObject?`	`0x1E8`	scripted
`ZoomStateMachineListenerID`	`red.CallbackObject?`	`0x1F8`	scripted
`advanceInteractionStateResolveDelayID`	`game.DelayID`	`0x208`	scripted
`activeStatusEffect`	`TDBID`	`0x210`	scripted
`activeProgramToUploadOnNPC`	`TDBID`	`0x218`	scripted
`isQhackUploadInProgerss`	`bool`	`0x220`	scripted
`scanningTweakDBRecord`	`TDBID`	`0x224`	scripted
`updateRunning`	`bool`	`0x22C`	scripted
`updateID`	`game.DelayID`	`0x230`	scripted
`delayedUpdateDeviceStateID`	`game.DelayID`	`0x238`	scripted
`blackboard`	`game.IBlackboard?`	`0x240`	scripted
`currentPlayerTargetCallbackID`	`red.CallbackObject?`	`0x250`	scripted
`wasLookedAtLast`	`bool`	`0x260`	scripted
`lastPingSourceID`	`ent.EntityID`	`0x268`	scripted
`networkGridBeamFX`	`game.FxResource`	`0x270`	scripted
`fxResourceMapper`	`FxResourceMapperComponent?`	`0x278`	scripted
`effectVisualization`	`AreaEffectVisualizationComponent?`	`0x288`	scripted
`resourceLibraryComponent`	`ResourceLibraryComponent?`	`0x298`	scripted
`gameplayRoleComponent`	`GameplayRoleComponent?`	`0x2A8`	scripted
`personalLinkHackSend`	`bool`	`0x2B8`	scripted
`personalLinkFailsafeID`	`game.DelayID`	`0x2BC`	scripted
`wasAnimationFastForwarded`	`bool`	`0x2C4`	scripted
`wasEngineeringSkillcheckTriggered`	`bool`	`0x2C5`	scripted
`contentScale`	`TDBID`	`0x2C8`	scripted
`networkGridBeamOffset`	`Vector4`	`0x2D0`	scripted
`areaEffectsData`	`SAreaEffectData[]`	`0x2E0`	scripted
`areaEffectsInFocusMode`	`SAreaEffectTargetData[]`	`0x2F0`	scripted
`debugOptions`	`DebuggerProperties`	`0x300`	scripted
`currentlyUploadingAction`	`WeakHandle<ScriptableDeviceAction>`	`0x328`	scripted
`workspotActivator`	`WeakHandle<game.Object>`	`0x338`	scripted

Functions

void DetermineInteractionStateByTask(game.GetActionsContext? context) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "DetermineInteractionStateByTask;GetActionsContext",
    (Device_DetermineInteractionStateByTask x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_DetermineInteractionStateByTask(
    Device self,
    game.GetActionsContext? context
);

void DetermineInteractionStateTask(game.ScriptTaskData data) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "DetermineInteractionStateTask;ScriptTaskData",
    (Device_DetermineInteractionStateTask x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_DetermineInteractionStateTask(
    Device self,
    game.ScriptTaskData? data
);

void ResolveGameplayStateByTask() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "ResolveGameplayStateByTask;",
    (Device_ResolveGameplayStateByTask x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_ResolveGameplayStateByTask(
    Device self
);

void ResolveGameplayStateTask(game.ScriptTaskData data) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "ResolveGameplayStateTask;ScriptTaskData",
    (Device_ResolveGameplayStateTask x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_ResolveGameplayStateTask(
    Device self,
    game.ScriptTaskData? data
);

bool OnRequestComponents(ent.EntityRequestComponentsInterface ri) overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnRequestComponents",
    (Device_OnRequestComponents x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnRequestComponents(
    Device self,
    ent.EntityRequestComponentsInterface ri
);

void OnMaraudersMapDeviceDebug(world.MaraudersMapDevicesSink sink) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "OnMaraudersMapDeviceDebug;MaraudersMapDevicesSink",
    (Device_OnMaraudersMapDeviceDebug x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnMaraudersMapDeviceDebug(
    Device self,
    world.MaraudersMapDevicesSink? sink
);

bool OnTakeControl(ent.EntityResolveComponentsInterface ri) overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnTakeControl",
    (Device_OnTakeControl x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnTakeControl(
    Device self,
    ent.EntityResolveComponentsInterface ri
);

bool OnDeviceVisible(game.DeviceVisibilityChangedEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnDeviceVisible",
    (Device_OnDeviceVisible x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnDeviceVisible(
    Device self,
    game.DeviceVisibilityChangedEvent? evt
);

bool WasVisible() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "WasVisible;",
    (Device_WasVisible x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_WasVisible(
    Device self
);

bool IsVisible() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "IsVisible;",
    (Device_IsVisible x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_IsVisible(
    Device self
);

void OnVisibilityChanged() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "OnVisibilityChanged;",
    (Device_OnVisibilityChanged x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnVisibilityChanged(
    Device self
);

bool OnGameAttached() overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnGameAttached",
    (Device_OnGameAttached x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnGameAttached(
    Device self
);

void ResolveGameplayState() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "ResolveGameplayState;",
    (Device_ResolveGameplayState x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_ResolveGameplayState(
    Device self
);

void SetLogicReady() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "SetLogicReady;",
    (Device_SetLogicReady x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_SetLogicReady(
    Device self
);

bool OnDetach() overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnDetach",
    (Device_OnDetach x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnDetach(
    Device self
);

bool OnPersitentStateInitialized(GameAttachedEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnPersitentStateInitialized",
    (Device_OnPersitentStateInitialized x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnPersitentStateInitialized(
    Device self,
    GameAttachedEvent? evt
);

bool OnLogicReady(SetLogicReadyEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnLogicReady",
    (Device_OnLogicReady x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnLogicReady(
    Device self,
    SetLogicReadyEvent? evt
);

bool IsInitialized() overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "IsInitialized;",
    (Device_IsInitialized x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_IsInitialized(
    Device self
);

bool IsDevice() overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "IsDevice;",
    (Device_IsDevice x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_IsDevice(
    Device self
);

void SetClearance() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "SetClearance;",
    (Device_SetClearance x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_SetClearance(
    Device self
);

void InitializeScanningData() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "InitializeScanningData;",
    (Device_InitializeScanningData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_InitializeScanningData(
    Device self
);

void InitializeScanningDataTask(game.ScriptTaskData data) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "InitializeScanningDataTask;ScriptTaskData",
    (Device_InitializeScanningDataTask x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_InitializeScanningDataTask(
    Device self,
    game.ScriptTaskData? data
);

bool ResavePersistentData(game.PersistentState ps) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "ResavePersistentData;PersistentState",
    (Device_ResavePersistentData x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_ResavePersistentData(
    Device self,
    game.PersistentState? ps
);

void PushData() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "PushData;",
    (Device_PushData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_PushData(
    Device self
);

void PushPersistentData() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "PushPersistentData;",
    (Device_PushPersistentData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_PushPersistentData(
    Device self
);

bool OnDeath(game.events.DeathEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnDeath",
    (Device_OnDeath x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnDeath(
    Device self,
    game.events.DeathEvent? evt
);

void Die() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "Die;",
    (Device_Die x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_Die(
    Device self
);

bool IsActionQueueEnabled() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "IsActionQueueEnabled;",
    (Device_IsActionQueueEnabled x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_IsActionQueueEnabled(
    Device self
);

bool IsActionQueueFull() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "IsActionQueueFull;",
    (Device_IsActionQueueFull x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_IsActionQueueFull(
    Device self
);

void SetCurrentlyUploadingAction(ScriptableDeviceAction action) overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "SetCurrentlyUploadingAction;ScriptableDeviceAction",
    (Device_SetCurrentlyUploadingAction x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_SetCurrentlyUploadingAction(
    Device self,
    ScriptableDeviceAction? action
);

ScriptableDeviceAction? GetCurrentlyUploadingAction() overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetCurrentlyUploadingAction;",
    (Device_GetCurrentlyUploadingAction x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ScriptableDeviceAction>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetCurrentlyUploadingAction(
    Device self
);

bool OnQuickSlotCommandUsed(QuickSlotCommandUsed evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnQuickSlotCommandUsed",
    (Device_OnQuickSlotCommandUsed x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnQuickSlotCommandUsed(
    Device self,
    QuickSlotCommandUsed? evt
);

void ExecuteAction(game.interactions.Choice choice, WeakHandle<game.Object> executor, CName layerTag) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "ExecuteAction;script_ref<InteractionChoice>GameObjectCName",
    (Device_ExecuteAction x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_ExecuteAction(
    Device self,
    game.interactions.Choice choice,
    WeakHandle<game.Object> executor,
    CName layerTag
);

bool ExecuteAction(game.device.Action action, WeakHandle<game.Object>? executor) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "ExecuteAction;DeviceActionGameObject",
    (Device_ExecuteAction2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_ExecuteAction2(
    Device self,
    game.device.Action? action,
    WeakHandle<game.Object>? executor
);

TDBID GetTweakDBRecord() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetTweakDBRecord;",
    (Device_GetTweakDBRecord x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.TDBID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetTweakDBRecord(
    Device self
);

void EnableUpdate(bool shouldEnable, float? time) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "EnableUpdate;BoolFloat",
    (Device_EnableUpdate x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_EnableUpdate(
    Device self,
    bool shouldEnable,
    float? time
);

void FireSingleTick() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "FireSingleTick;",
    (Device_FireSingleTick x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_FireSingleTick(
    Device self
);

bool OnCancelUpdateEvent(CancelDeviceUpdateEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnCancelUpdateEvent",
    (Device_OnCancelUpdateEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnCancelUpdateEvent(
    Device self,
    CancelDeviceUpdateEvent? evt
);

bool OnDeviceUpdate(DeviceUpdateEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnDeviceUpdate",
    (Device_OnDeviceUpdate x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnDeviceUpdate(
    Device self,
    DeviceUpdateEvent? evt
);

void DeviceUpdate() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "DeviceUpdate;",
    (Device_DeviceUpdate x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_DeviceUpdate(
    Device self
);

void RestoreDeviceState() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "RestoreDeviceState;",
    (Device_RestoreDeviceState x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_RestoreDeviceState(
    Device self
);

bool UpdateDeviceState(bool? isDelayed) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "UpdateDeviceState;Bool",
    (Device_UpdateDeviceState x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_UpdateDeviceState(
    Device self,
    bool? isDelayed
);

bool OnDelayedUpdateDeviceStateEvent(DelayedUpdateDeviceStateEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnDelayedUpdateDeviceStateEvent",
    (Device_OnDelayedUpdateDeviceStateEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnDelayedUpdateDeviceStateEvent(
    Device self,
    DelayedUpdateDeviceStateEvent? evt
);

bool OnSlaveStateChanged(game.PSDeviceChangedEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnSlaveStateChanged",
    (Device_OnSlaveStateChanged x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnSlaveStateChanged(
    Device self,
    game.PSDeviceChangedEvent? evt
);

bool OnPSChangedEvent(game.PSChangedEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnPSChangedEvent",
    (Device_OnPSChangedEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnPSChangedEvent(
    Device self,
    game.PSChangedEvent? evt
);

DeviceLinkComponentPS? GetDeviceLink() overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetDeviceLink;",
    (Device_GetDeviceLink x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.DeviceLinkComponentPS>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetDeviceLink(
    Device self
);

ScriptableDeviceComponent? GetController() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetController;",
    (Device_GetController x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ScriptableDeviceComponent>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetController(
    Device self
);

void SendEventToDefaultPS(red.Event evt) overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "SendEventToDefaultPS;Event",
    (Device_SendEventToDefaultPS x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_SendEventToDefaultPS(
    Device self,
    red.Event? evt
);

ScriptableDeviceComponentPS? GetDevicePS() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetDevicePS;",
    (Device_GetDevicePS x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ScriptableDeviceComponentPS>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetDevicePS(
    Device self
);

CName GetPSName() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetPSName;",
    (Device_GetPSName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetPSName(
    Device self
);

CName GetPSClassName() overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetPSClassName;",
    (Device_GetPSClassName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetPSClassName(
    Device self
);

void NotifyParents() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "NotifyParents;",
    (Device_NotifyParents x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_NotifyParents(
    Device self
);

bool OnNotifyParents(NotifyParentsEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnNotifyParents",
    (Device_OnNotifyParents x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnNotifyParents(
    Device self,
    NotifyParentsEvent? evt
);

game.GetActionsContext GetContext(game.Object? processInitiator, game.device.RequestType? requestType) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetContext;GameObjectgamedeviceRequestType",
    (Device_GetContext x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.GetActionsContext>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetContext(
    Device self,
    game.Object? processInitiator,
    game.device.RequestType? requestType
);

bool IsPlayerAround() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "IsPlayerAround;",
    (Device_IsPlayerAround x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_IsPlayerAround(
    Device self
);

CName GetInputContextName() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetInputContextName;",
    (Device_GetInputContextName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetInputContextName(
    Device self
);

string GetDeviceName() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetDeviceName;",
    (Device_GetDeviceName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetDeviceName(
    Device self
);

string GetDeviceStatusString() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetDeviceStatusString;",
    (Device_GetDeviceStatusString x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetDeviceStatusString(
    Device self
);

EDeviceStatus GetDeviceState() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetDeviceState;",
    (Device_GetDeviceState x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EDeviceStatus>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetDeviceState(
    Device self
);

bool IsDeviceSecured() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "IsDeviceSecured;",
    (Device_IsDeviceSecured x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_IsDeviceSecured(
    Device self
);

ent.LocalizationStringComponent? GetLocalization() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetLocalization;",
    (Device_GetLocalization x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ent.LocalizationStringComponent>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetLocalization(
    Device self
);

DeviceBaseBlackboardDef? GetBlackboardDef() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetBlackboardDef;",
    (Device_GetBlackboardDef x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.DeviceBaseBlackboardDef>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetBlackboardDef(
    Device self
);

game.IBlackboard? GetBlackboard() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetBlackboard;",
    (Device_GetBlackboard x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.IBlackboard>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetBlackboard(
    Device self
);

DeviceInkGameControllerBase? GetGameController() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetGameController;",
    (Device_GetGameController x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.DeviceInkGameControllerBase>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetGameController(
    Device self
);

ScreenDefinitionPackage GetScreenDefinition() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetScreenDefinition;",
    (Device_GetScreenDefinition x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ScreenDefinitionPackage>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetScreenDefinition(
    Device self
);

bool IsUIdirty() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "IsUIdirty;",
    (Device_IsUIdirty x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_IsUIdirty(
    Device self
);

bool IsReadyForUI() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "IsReadyForUI;",
    (Device_IsReadyForUI x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_IsReadyForUI(
    Device self
);

DebuggerProperties GetDebuggerProperties() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetDebuggerProperties;",
    (Device_GetDebuggerProperties x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.DebuggerProperties>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetDebuggerProperties(
    Device self
);

void CreateBlackboard() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "CreateBlackboard;",
    (Device_CreateBlackboard x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_CreateBlackboard(
    Device self
);

bool ShouldEnableRemoteLayer() overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "ShouldEnableRemoteLayer;",
    (Device_ShouldEnableRemoteLayer x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_ShouldEnableRemoteLayer(
    Device self
);

bool IsConnectedToBackdoorDevice() overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "IsConnectedToBackdoorDevice;",
    (Device_IsConnectedToBackdoorDevice x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_IsConnectedToBackdoorDevice(
    Device self
);

bool IsBackdoor() overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "IsBackdoor;",
    (Device_IsBackdoor x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_IsBackdoor(
    Device self
);

bool IsActiveBackdoor() overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "IsActiveBackdoor;",
    (Device_IsActiveBackdoor x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_IsActiveBackdoor(
    Device self
);

bool IsQuickHackAble() overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "IsQuickHackAble;",
    (Device_IsQuickHackAble x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_IsQuickHackAble(
    Device self
);

bool IsPotentiallyQuickHackable() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "IsPotentiallyQuickHackable;",
    (Device_IsPotentiallyQuickHackable x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_IsPotentiallyQuickHackable(
    Device self
);

bool IsQuickHacksExposed() overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "IsQuickHacksExposed;",
    (Device_IsQuickHacksExposed x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_IsQuickHacksExposed(
    Device self
);

bool IsBreached() overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "IsBreached;",
    (Device_IsBreached x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_IsBreached(
    Device self
);

string GetNetworkSecurityLevel() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetNetworkSecurityLevel;",
    (Device_GetNetworkSecurityLevel x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetNetworkSecurityLevel(
    Device self
);

bool IsControllingDevices() overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "IsControllingDevices;",
    (Device_IsControllingDevices x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_IsControllingDevices(
    Device self
);

bool HasAnySlaveDevices() overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "HasAnySlaveDevices;",
    (Device_HasAnySlaveDevices x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_HasAnySlaveDevices(
    Device self
);

bool HasImportantInteraction() overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "HasImportantInteraction;",
    (Device_HasImportantInteraction x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_HasImportantInteraction(
    Device self
);

bool ShouldRevealDevicesGrid() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "ShouldRevealDevicesGrid;",
    (Device_ShouldRevealDevicesGrid x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_ShouldRevealDevicesGrid(
    Device self
);

SecuritySystemControllerPS? GetSecuritySystem() overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetSecuritySystem;",
    (Device_GetSecuritySystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.SecuritySystemControllerPS>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetSecuritySystem(
    Device self
);

bool IsConnectedToSecuritySystem() overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "IsConnectedToSecuritySystem;",
    (Device_IsConnectedToSecuritySystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_IsConnectedToSecuritySystem(
    Device self
);

bool IsConnectedToActionsSequencer() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "IsConnectedToActionsSequencer;",
    (Device_IsConnectedToActionsSequencer x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_IsConnectedToActionsSequencer(
    Device self
);

bool IsLockedViaSequencer() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "IsLockedViaSequencer;",
    (Device_IsLockedViaSequencer x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_IsLockedViaSequencer(
    Device self
);

bool IsTargetTresspassingMyZone(game.Object target) overrideRTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct Device_IsTargetTresspassingMyZone(
    Device self,
    game.Object? target
);

FxResourceMapperComponent? GetFxResourceMapper() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetFxResourceMapper;",
    (Device_GetFxResourceMapper x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.FxResourceMapperComponent>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetFxResourceMapper(
    Device self
);

ResourceLibraryComponent? GetResourceLibrary() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetResourceLibrary;",
    (Device_GetResourceLibrary x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ResourceLibraryComponent>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetResourceLibrary(
    Device self
);

bool OnDurabilityLimitReach(DurabilityLimitReach evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnDurabilityLimitReach",
    (Device_OnDurabilityLimitReach x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnDurabilityLimitReach(
    Device self,
    DurabilityLimitReach? evt
);

bool OnChangeJuryrigTrapState(ChangeJuryrigTrapState evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnChangeJuryrigTrapState",
    (Device_OnChangeJuryrigTrapState x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnChangeJuryrigTrapState(
    Device self,
    ChangeJuryrigTrapState? evt
);

bool OnPerformedAction(PerformedAction evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnPerformedAction",
    (Device_OnPerformedAction x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnPerformedAction(
    Device self,
    PerformedAction? evt
);

void ResolveIllegalAction(game.Object executor, float duration) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "ResolveIllegalAction;GameObjectFloat",
    (Device_ResolveIllegalAction x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_ResolveIllegalAction(
    Device self,
    game.Object? executor,
    float duration
);

void FastForwardAnimations() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "FastForwardAnimations;",
    (Device_FastForwardAnimations x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_FastForwardAnimations(
    Device self
);

bool OnToggleON(ToggleON evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnToggleON",
    (Device_OnToggleON x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnToggleON(
    Device self,
    ToggleON? evt
);

bool OnToggleActivation(ToggleActivation evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnToggleActivation",
    (Device_OnToggleActivation x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnToggleActivation(
    Device self,
    ToggleActivation? evt
);

bool OnTogglePower(TogglePower evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnTogglePower",
    (Device_OnTogglePower x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnTogglePower(
    Device self,
    TogglePower? evt
);

bool OnSetDeviceUnpowered(SetDeviceUnpowered evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnSetDeviceUnpowered",
    (Device_OnSetDeviceUnpowered x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnSetDeviceUnpowered(
    Device self,
    SetDeviceUnpowered? evt
);

bool OnSetDevicePowered(SetDevicePowered evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnSetDevicePowered",
    (Device_OnSetDevicePowered x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnSetDevicePowered(
    Device self,
    SetDevicePowered? evt
);

bool OnSetON(SetDeviceON evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnSetON",
    (Device_OnSetON x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnSetON(
    Device self,
    SetDeviceON? evt
);

bool OnSetOFF(SetDeviceOFF evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnSetOFF",
    (Device_OnSetOFF x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnSetOFF(
    Device self,
    SetDeviceOFF? evt
);

bool OnAuthorizeUser(AuthorizeUser evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnAuthorizeUser",
    (Device_OnAuthorizeUser x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnAuthorizeUser(
    Device self,
    AuthorizeUser? evt
);

bool OnSetAuthorizationModuleON(SetAuthorizationModuleON evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnSetAuthorizationModuleON",
    (Device_OnSetAuthorizationModuleON x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnSetAuthorizationModuleON(
    Device self,
    SetAuthorizationModuleON? evt
);

bool OnSetAuthorizationModuleOFF(SetAuthorizationModuleOFF evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnSetAuthorizationModuleOFF",
    (Device_OnSetAuthorizationModuleOFF x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnSetAuthorizationModuleOFF(
    Device self,
    SetAuthorizationModuleOFF? evt
);

bool OnDisassembleDevice(DisassembleDevice evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnDisassembleDevice",
    (Device_OnDisassembleDevice x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnDisassembleDevice(
    Device self,
    DisassembleDevice? evt
);

bool OnToggleJuryrigTrap(ToggleJuryrigTrap evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnToggleJuryrigTrap",
    (Device_OnToggleJuryrigTrap x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnToggleJuryrigTrap(
    Device self,
    ToggleJuryrigTrap? evt
);

bool OnTogglePersonalLink(TogglePersonalLink evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnTogglePersonalLink",
    (Device_OnTogglePersonalLink x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnTogglePersonalLink(
    Device self,
    TogglePersonalLink? evt
);

void TogglePersonalLink(bool toggle, game.Object puppet) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "TogglePersonalLink;BoolGameObject",
    (Device_TogglePersonalLink x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_TogglePersonalLink(
    Device self,
    bool toggle,
    game.Object? puppet
);

void InitiatePersonalLinkWorkspot(game.Object puppet) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "InitiatePersonalLinkWorkspot;GameObject",
    (Device_InitiatePersonalLinkWorkspot x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_InitiatePersonalLinkWorkspot(
    Device self,
    game.Object? puppet
);

CName GetSlotTag() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetSlotTag;",
    (Device_GetSlotTag x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetSlotTag(
    Device self
);

bool OnRepeatApplyAnimFeatureHACK(RepeatPersonalLinkAnimFeaturesHACK evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnRepeatApplyAnimFeatureHACK",
    (Device_OnRepeatApplyAnimFeatureHACK x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnRepeatApplyAnimFeatureHACK(
    Device self,
    RepeatPersonalLinkAnimFeaturesHACK? evt
);

bool OnToggleZoomInteraction(ToggleZoomInteraction evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnToggleZoomInteraction",
    (Device_OnToggleZoomInteraction x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnToggleZoomInteraction(
    Device self,
    ToggleZoomInteraction? evt
);

bool OnQuestForceCameraZoom(QuestForceCameraZoom evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnQuestForceCameraZoom",
    (Device_OnQuestForceCameraZoom x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnQuestForceCameraZoom(
    Device self,
    QuestForceCameraZoom? evt
);

void EvaluateCameraZoomState(game.Object executor, bool? instant) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "EvaluateCameraZoomState;GameObjectBool",
    (Device_EvaluateCameraZoomState x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_EvaluateCameraZoomState(
    Device self,
    game.Object? executor,
    bool? instant
);

bool ShouldExitZoomOnAuthorization() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "ShouldExitZoomOnAuthorization;",
    (Device_ShouldExitZoomOnAuthorization x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_ShouldExitZoomOnAuthorization(
    Device self
);

void ShowAdvanceInteractionInputHints() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "ShowAdvanceInteractionInputHints;",
    (Device_ShowAdvanceInteractionInputHints x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_ShowAdvanceInteractionInputHints(
    Device self
);

void HideAdvanceInteractionInputHints() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "HideAdvanceInteractionInputHints;",
    (Device_HideAdvanceInteractionInputHints x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_HideAdvanceInteractionInputHints(
    Device self
);

void ToggleCameraZoom(bool toggle, bool? instant) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "ToggleCameraZoom;BoolBool",
    (Device_ToggleCameraZoom x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_ToggleCameraZoom(
    Device self,
    bool toggle,
    bool? instant
);

bool OnIsUIZoomDeviceChange(bool value) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnIsUIZoomDeviceChange",
    (Device_OnIsUIZoomDeviceChange x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnIsUIZoomDeviceChange(
    Device self,
    bool value
);

bool OnUnregisterFromZoomBlackboardEvent(UnregisterFromZoomBlackboardEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnUnregisterFromZoomBlackboardEvent",
    (Device_OnUnregisterFromZoomBlackboardEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnUnregisterFromZoomBlackboardEvent(
    Device self,
    UnregisterFromZoomBlackboardEvent? evt
);

bool OnOpenFullscreenUI(OpenFullscreenUI evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnOpenFullscreenUI",
    (Device_OnOpenFullscreenUI x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnOpenFullscreenUI(
    Device self,
    OpenFullscreenUI? evt
);

void RegisterPlayerInputListener(bool shouldRegister) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "RegisterPlayerInputListener;Bool",
    (Device_RegisterPlayerInputListener x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_RegisterPlayerInputListener(
    Device self,
    bool shouldRegister
);

bool OnQuestForceEnabled(QuestForceEnabled evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnQuestForceEnabled",
    (Device_OnQuestForceEnabled x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnQuestForceEnabled(
    Device self,
    QuestForceEnabled? evt
);

bool OnQuestForceDisabled(QuestForceDisabled evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnQuestForceDisabled",
    (Device_OnQuestForceDisabled x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnQuestForceDisabled(
    Device self,
    QuestForceDisabled? evt
);

bool OnQuestForcePower(QuestForcePower evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnQuestForcePower",
    (Device_OnQuestForcePower x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnQuestForcePower(
    Device self,
    QuestForcePower? evt
);

bool OnQuestForceUnpower(QuestForceUnpower evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnQuestForceUnpower",
    (Device_OnQuestForceUnpower x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnQuestForceUnpower(
    Device self,
    QuestForceUnpower? evt
);

bool OnQuestForceEnableAuthorization(QuestForceAuthorizationEnabled evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnQuestForceEnableAuthorization",
    (Device_OnQuestForceEnableAuthorization x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnQuestForceEnableAuthorization(
    Device self,
    QuestForceAuthorizationEnabled? evt
);

bool OnQuestForceDisableAuthorization(QuestForceAuthorizationDisabled evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnQuestForceDisableAuthorization",
    (Device_OnQuestForceDisableAuthorization x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnQuestForceDisableAuthorization(
    Device self,
    QuestForceAuthorizationDisabled? evt
);

bool OnQuestForceArmJuryrigTrap(QuestForceJuryrigTrapArmed evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnQuestForceArmJuryrigTrap",
    (Device_OnQuestForceArmJuryrigTrap x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnQuestForceArmJuryrigTrap(
    Device self,
    QuestForceJuryrigTrapArmed? evt
);

bool OnQuestForceDeactivateJuryrigTrap(QuestForceJuryrigTrapDeactivated evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnQuestForceDeactivateJuryrigTrap",
    (Device_OnQuestForceDeactivateJuryrigTrap x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnQuestForceDeactivateJuryrigTrap(
    Device self,
    QuestForceJuryrigTrapDeactivated? evt
);

bool OnQuestForceON(QuestForceON evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnQuestForceON",
    (Device_OnQuestForceON x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnQuestForceON(
    Device self,
    QuestForceON? evt
);

bool OnQuestForceOFF(QuestForceOFF evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnQuestForceOFF",
    (Device_OnQuestForceOFF x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnQuestForceOFF(
    Device self,
    QuestForceOFF? evt
);

bool OnQuestForceSecuritySystemSafe(QuestForceSecuritySystemSafe evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnQuestForceSecuritySystemSafe",
    (Device_OnQuestForceSecuritySystemSafe x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnQuestForceSecuritySystemSafe(
    Device self,
    QuestForceSecuritySystemSafe? evt
);

bool OnQuestForceSecuritySystemAlarmed(QuestForceSecuritySystemAlarmed evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnQuestForceSecuritySystemAlarmed",
    (Device_OnQuestForceSecuritySystemAlarmed x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnQuestForceSecuritySystemAlarmed(
    Device self,
    QuestForceSecuritySystemAlarmed? evt
);

bool OnQuestForceSecuritySystemArmed(QuestForceSecuritySystemArmed evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnQuestForceSecuritySystemArmed",
    (Device_OnQuestForceSecuritySystemArmed x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnQuestForceSecuritySystemArmed(
    Device self,
    QuestForceSecuritySystemArmed? evt
);

bool OnAttitudeChanged(game.events.AttitudeChangedEvent evt) overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnAttitudeChanged",
    (Device_OnAttitudeChanged x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnAttitudeChanged(
    Device self,
    game.events.AttitudeChangedEvent? evt
);

bool OnSecuritySystemOutput(SecuritySystemOutput evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnSecuritySystemOutput",
    (Device_OnSecuritySystemOutput x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnSecuritySystemOutput(
    Device self,
    SecuritySystemOutput? evt
);

bool OnSecuritySystemForceAttitudeChange(SecuritySystemForceAttitudeChange evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnSecuritySystemForceAttitudeChange",
    (Device_OnSecuritySystemForceAttitudeChange x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnSecuritySystemForceAttitudeChange(
    Device self,
    SecuritySystemForceAttitudeChange? evt
);

bool OnSecurityAreaCrossingPerimeter(SecurityAreaCrossingPerimeter evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnSecurityAreaCrossingPerimeter",
    (Device_OnSecurityAreaCrossingPerimeter x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnSecurityAreaCrossingPerimeter(
    Device self,
    SecurityAreaCrossingPerimeter? evt
);

void InitializeScreenDefinition() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "InitializeScreenDefinition;",
    (Device_InitializeScreenDefinition x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_InitializeScreenDefinition(
    Device self
);

bool ShouldAlwasyRefreshUIInLogicAra() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "ShouldAlwasyRefreshUIInLogicAra;",
    (Device_ShouldAlwasyRefreshUIInLogicAra x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_ShouldAlwasyRefreshUIInLogicAra(
    Device self
);

void RefreshUI(bool? isDelayed) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "RefreshUI;Bool",
    (Device_RefreshUI x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_RefreshUI(
    Device self,
    bool? isDelayed
);

bool OnToggleUIInteractivity(ToggleUIInteractivity evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnToggleUIInteractivity",
    (Device_OnToggleUIInteractivity x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnToggleUIInteractivity(
    Device self,
    ToggleUIInteractivity? evt
);

bool OnUIAction(UIActionEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnUIAction",
    (Device_OnUIAction x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnUIAction(
    Device self,
    UIActionEvent? evt
);

bool OnRequestUiRefresh(RequestUIRefreshEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnRequestUiRefresh",
    (Device_OnRequestUiRefresh x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnRequestUiRefresh(
    Device self,
    RequestUIRefreshEvent? evt
);

bool OnRequesBreadCrumbBarUpdate(RequestBreadCrumbBarUpdateEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnRequesBreadCrumbBarUpdate",
    (Device_OnRequesBreadCrumbBarUpdate x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnRequesBreadCrumbBarUpdate(
    Device self,
    RequestBreadCrumbBarUpdateEvent? evt
);

bool OnRequestActionWidgetsUpdate(RequestActionWidgetsUpdateEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnRequestActionWidgetsUpdate",
    (Device_OnRequestActionWidgetsUpdate x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnRequestActionWidgetsUpdate(
    Device self,
    RequestActionWidgetsUpdateEvent? evt
);

bool OnDeviceWidgetUpdate(RequestDeviceWidgetUpdateEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnDeviceWidgetUpdate",
    (Device_OnDeviceWidgetUpdate x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnDeviceWidgetUpdate(
    Device self,
    RequestDeviceWidgetUpdateEvent? evt
);

void RequestActionWidgetsUpdate(game.IBlackboard blackboard) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "RequestActionWidgetsUpdate;IBlackboard",
    (Device_RequestActionWidgetsUpdate x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_RequestActionWidgetsUpdate(
    Device self,
    game.IBlackboard? blackboard
);

void RequestDeviceWidgetsUpdate(game.IBlackboard blackboard) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "RequestDeviceWidgetsUpdate;IBlackboard",
    (Device_RequestDeviceWidgetsUpdate x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_RequestDeviceWidgetsUpdate(
    Device self,
    game.IBlackboard? blackboard
);

void RequestThumbnailWidgetsUpdate(game.IBlackboard blackboard) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "RequestThumbnailWidgetsUpdate;IBlackboard",
    (Device_RequestThumbnailWidgetsUpdate x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_RequestThumbnailWidgetsUpdate(
    Device self,
    game.IBlackboard? blackboard
);

void SetZoomBlackboardValues(bool newState, float? lockPlayerFor) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "SetZoomBlackboardValues;BoolFloat",
    (Device_SetZoomBlackboardValues x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_SetZoomBlackboardValues(
    Device self,
    bool newState,
    float? lockPlayerFor
);

bool OnAdvanceInteractionStateResolveEvent(AdvanceInteractionStateResolveEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnAdvanceInteractionStateResolveEvent",
    (Device_OnAdvanceInteractionStateResolveEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnAdvanceInteractionStateResolveEvent(
    Device self,
    AdvanceInteractionStateResolveEvent? evt
);

void EnterWorkspot(game.Object activator, bool? freeCamera, CName? componentName, CName? deviceData) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "EnterWorkspot;GameObjectBoolCNameCName",
    (Device_EnterWorkspot x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_EnterWorkspot(
    Device self,
    game.Object? activator,
    bool? freeCamera,
    CName? componentName,
    CName? deviceData
);

bool OnPlayInDeviceCallbackEvent(game.PlayInDeviceCallbackEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnPlayInDeviceCallbackEvent",
    (Device_OnPlayInDeviceCallbackEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnPlayInDeviceCallbackEvent(
    Device self,
    game.PlayInDeviceCallbackEvent? evt
);

void EnterWorkspotWithIK(game.Object activator, bool shouldCrouch, CName? cameraFlavour, CName? componentName, Vector4? cameraPosition, Quaternion? cameraRotation, Vector4? rightHandPosition, Quaternion? rightHandRotation, Vector4? leftHandPosition, Quaternion? leftHandRotation)

RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "EnterWorkspotWithIK;GameObjectBoolCNameCNameVector4QuaternionVector4QuaternionVector4Quaternion",
    (Device_EnterWorkspotWithIK x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_EnterWorkspotWithIK(
    Device self,
    game.Object? activator,
    bool shouldCrouch,
    CName? cameraFlavour,
    CName? componentName,
    Vector4? cameraPosition,
    Quaternion? cameraRotation,
    Vector4? rightHandPosition,
    Quaternion? rightHandRotation,
    Vector4? leftHandPosition,
    Quaternion? leftHandRotation
);

void LeaveWorkspot(game.Object activator) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "LeaveWorkspot;GameObject",
    (Device_LeaveWorkspot x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_LeaveWorkspot(
    Device self,
    game.Object? activator
);

bool OnWorkspotFinished(CName componentName) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnWorkspotFinished",
    (Device_OnWorkspotFinished x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnWorkspotFinished(
    Device self,
    CName componentName
);

bool OnMissingWorkspotComponentFailsafeEvent(MissingWorkspotComponentFailsafeEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnMissingWorkspotComponentFailsafeEvent",
    (Device_OnMissingWorkspotComponentFailsafeEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnMissingWorkspotComponentFailsafeEvent(
    Device self,
    MissingWorkspotComponentFailsafeEvent? evt
);

void DetermineInteractionState(game.GetActionsContext? context) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "DetermineInteractionState;GetActionsContext",
    (Device_DetermineInteractionState x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_DetermineInteractionState(
    Device self,
    game.GetActionsContext? context
);

void ResetChoicesByEvent() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "ResetChoicesByEvent;",
    (Device_ResetChoicesByEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_ResetChoicesByEvent(
    Device self
);

void AdjustInteractionComponent() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "AdjustInteractionComponent;",
    (Device_AdjustInteractionComponent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_AdjustInteractionComponent(
    Device self
);

bool IsDirectInteractionCondition() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "IsDirectInteractionCondition;",
    (Device_IsDirectInteractionCondition x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_IsDirectInteractionCondition(
    Device self
);

void ExecuteDeviceStateOperation() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "ExecuteDeviceStateOperation;",
    (Device_ExecuteDeviceStateOperation x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_ExecuteDeviceStateOperation(
    Device self
);

void ExecuteBaseActionOperation(CName actionClassName) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "ExecuteBaseActionOperation;CName",
    (Device_ExecuteBaseActionOperation x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_ExecuteBaseActionOperation(
    Device self,
    CName actionClassName
);

void RestoreBaseActionOperations() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "RestoreBaseActionOperations;",
    (Device_RestoreBaseActionOperations x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_RestoreBaseActionOperations(
    Device self
);

void SetJuryrigTrapComponentState(bool newState) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "SetJuryrigTrapComponentState;Bool",
    (Device_SetJuryrigTrapComponentState x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_SetJuryrigTrapComponentState(
    Device self,
    bool newState
);

void SetJuryrigTrapState(EJuryrigTrapState newState) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "SetJuryrigTrapState;EJuryrigTrapState",
    (Device_SetJuryrigTrapState x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_SetJuryrigTrapState(
    Device self,
    EJuryrigTrapState newState
);

bool ShouldShowScanner() overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "ShouldShowScanner;",
    (Device_ShouldShowScanner x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_ShouldShowScanner(
    Device self
);

void FillObjectDescription(out game.ScanningTooltipElementDef[] arr) overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "FillObjectDescription;array<ScanningTooltipElementDef>",
    (Device_FillObjectDescription x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_FillObjectDescription(
    Device self,
    game.ScanningTooltipElementDef[] arr
);

bool CompileScannerChunks() overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "CompileScannerChunks;",
    (Device_CompileScannerChunks x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_CompileScannerChunks(
    Device self
);

string GetScannerName() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetScannerName;",
    (Device_GetScannerName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetScannerName(
    Device self
);

TDBID GetScannerAttitudeTweak() overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetScannerAttitudeTweak;",
    (Device_GetScannerAttitudeTweak x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.TDBID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetScannerAttitudeTweak(
    Device self
);

void SetScanningProgressBarText() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "SetScanningProgressBarText;",
    (Device_SetScanningProgressBarText x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_SetScanningProgressBarText(
    Device self
);

bool ShouldShowDamageNumber() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "ShouldShowDamageNumber;",
    (Device_ShouldShowDamageNumber x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_ShouldShowDamageNumber(
    Device self
);

void ReactToHit(game.events.HitEvent hit) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "ReactToHit;gameHitEvent",
    (Device_ReactToHit x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_ReactToHit(
    Device self,
    game.events.HitEvent? hit
);

Vector4 GetHitSourcePosition(ent.EntityID hitSourceEntityID) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetHitSourcePosition;EntityID",
    (Device_GetHitSourcePosition x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector4>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetHitSourcePosition(
    Device self,
    ent.EntityID hitSourceEntityID
);

void ControlledDeviceInputAction(bool isPressed) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "ControlledDeviceInputAction;Bool",
    (Device_ControlledDeviceInputAction x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_ControlledDeviceInputAction(
    Device self,
    bool isPressed
);

void PlayEffect(CName effectEventName, CName effectEventTag) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "PlayEffect;CNameCName",
    (Device_PlayEffect x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_PlayEffect(
    Device self,
    CName effectEventName,
    CName effectEventTag
);

void SetMeshAppearance(CName appearance, CName? component) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "SetMeshAppearance;CNameCName",
    (Device_SetMeshAppearance x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_SetMeshAppearance(
    Device self,
    CName appearance,
    CName? component
);

game.Object? GetPlayerMainObject() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetPlayerMainObject;",
    (Device_GetPlayerMainObject x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.GameObject>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetPlayerMainObject(
    Device self
);

ent.EntityID ExtractEntityID(ent.TriggerEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "ExtractEntityID;TriggerEvent",
    (Device_ExtractEntityID x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ent.EntityID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_ExtractEntityID(
    Device self,
    ent.TriggerEvent? evt
);

bool IsPlayer(ent.EntityID entityID) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "IsPlayer;EntityID",
    (Device_IsPlayer x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_IsPlayer(
    Device self,
    ent.EntityID entityID
);

void ActivateDevice() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "ActivateDevice;",
    (Device_ActivateDevice x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_ActivateDevice(
    Device self
);

void DeactivateDevice() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "DeactivateDevice;",
    (Device_DeactivateDevice x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_DeactivateDevice(
    Device self
);

void RestorePower() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "RestorePower;",
    (Device_RestorePower x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_RestorePower(
    Device self
);

void CutPower() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "CutPower;",
    (Device_CutPower x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_CutPower(
    Device self
);

void TurnAuthorizationModuleON() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "TurnAuthorizationModuleON;",
    (Device_TurnAuthorizationModuleON x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_TurnAuthorizationModuleON(
    Device self
);

void TurnAuthorizationModuleOFF() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "TurnAuthorizationModuleOFF;",
    (Device_TurnAuthorizationModuleOFF x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_TurnAuthorizationModuleOFF(
    Device self
);

void ArmJuryrigTrap() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "ArmJuryrigTrap;",
    (Device_ArmJuryrigTrap x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_ArmJuryrigTrap(
    Device self
);

void DeactivateJuryrigTrap() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "DeactivateJuryrigTrap;",
    (Device_DeactivateJuryrigTrap x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_DeactivateJuryrigTrap(
    Device self
);

void TurnOnDevice() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "TurnOnDevice;",
    (Device_TurnOnDevice x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_TurnOnDevice(
    Device self
);

void TurnOffDevice() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "TurnOffDevice;",
    (Device_TurnOffDevice x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_TurnOffDevice(
    Device self
);

void BreakDevice() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "BreakDevice;",
    (Device_BreakDevice x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_BreakDevice(
    Device self
);

void SetStateSafe() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "SetStateSafe;",
    (Device_SetStateSafe x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_SetStateSafe(
    Device self
);

void SetStateAlarmed() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "SetStateAlarmed;",
    (Device_SetStateAlarmed x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_SetStateAlarmed(
    Device self
);

void SetStateArmed() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "SetStateArmed;",
    (Device_SetStateArmed x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_SetStateArmed(
    Device self
);

bool GetActionsDebug(game.GetActionsContext context, DeviceDebuggerComponent debugger, out game.device.Action[] outActions)

RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetActionsDebug;script_ref<GetActionsContext>DeviceDebuggerComponentarray<DeviceAction>",
    (Device_GetActionsDebug x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetActionsDebug(
    Device self,
    game.GetActionsContext context,
    DeviceDebuggerComponent? debugger,
    game.device.Action[] outActions
);

bool ShouldInitiateDebug() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "ShouldInitiateDebug;",
    (Device_ShouldInitiateDebug x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_ShouldInitiateDebug(
    Device self
);

bool OnHUDInstruction(HUDInstruction evt) overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnHUDInstruction",
    (Device_OnHUDInstruction x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnHUDInstruction(
    Device self,
    HUDInstruction? evt
);

bool OnScanningActionFinishedEvent(game.ScanningActionFinishedEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnScanningActionFinishedEvent",
    (Device_OnScanningActionFinishedEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnScanningActionFinishedEvent(
    Device self,
    game.ScanningActionFinishedEvent? evt
);

bool CanRevealRemoteActionsWheel() overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "CanRevealRemoteActionsWheel;",
    (Device_CanRevealRemoteActionsWheel x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_CanRevealRemoteActionsWheel(
    Device self
);

bool OnQuickHackPanelStateChanged(QuickHackPanelStateEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnQuickHackPanelStateChanged",
    (Device_OnQuickHackPanelStateChanged x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnQuickHackPanelStateChanged(
    Device self,
    QuickHackPanelStateEvent? evt
);

bool HasDirectActionsActive() overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "HasDirectActionsActive;",
    (Device_HasDirectActionsActive x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_HasDirectActionsActive(
    Device self
);

int GetBlackboardIntVariable(game.bb.ScriptID_Int32 id) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetBlackboardIntVariable;BlackboardID_Int",
    (Device_GetBlackboardIntVariable x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetBlackboardIntVariable(
    Device self,
    game.bb.ScriptID_Int32 id
);

void SendQuickhackCommands(bool shouldOpen) overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "SendQuickhackCommands;Bool",
    (Device_SendQuickhackCommands x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_SendQuickhackCommands(
    Device self,
    bool shouldOpen
);

List GetPlayerCyberDeck() RTTI

int GetMatchingActionProgramName(game.device.Action[] actions, string searchWord) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetMatchingActionProgramName;script_ref<array<DeviceAction>>script_ref<String>",
    (Device_GetMatchingActionProgramName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetMatchingActionProgramName(
    Device self,
    game.device.Action[] actions,
    string searchWord
);

bool OnUploadProgressStateChanged(UploadProgramProgressEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnUploadProgressStateChanged",
    (Device_OnUploadProgressStateChanged x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnUploadProgressStateChanged(
    Device self,
    UploadProgramProgressEvent? evt
);

void ShowQuickHackDuration(ScriptableDeviceAction action) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "ShowQuickHackDuration;ScriptableDeviceAction",
    (Device_ShowQuickHackDuration x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_ShowQuickHackDuration(
    Device self,
    ScriptableDeviceAction? action
);

bool CanPlayerUseQuickHackVulnerability(TDBID data) overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "CanPlayerUseQuickHackVulnerability;TweakDBID",
    (Device_CanPlayerUseQuickHackVulnerability x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_CanPlayerUseQuickHackVulnerability(
    Device self,
    TDBID data
);

void ResolveRemoteActions(bool state) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "ResolveRemoteActions;Bool",
    (Device_ResolveRemoteActions x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_ResolveRemoteActions(
    Device self,
    bool state
);

void RefreshInteraction() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "RefreshInteraction;",
    (Device_RefreshInteraction x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_RefreshInteraction(
    Device self
);

bool OnScanningLookedAt(game.ScanningLookAtEvent evt) overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnScanningLookedAt",
    (Device_OnScanningLookedAt x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnScanningLookedAt(
    Device self,
    game.ScanningLookAtEvent? evt
);

bool ShouldPulseNetwork() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "ShouldPulseNetwork;",
    (Device_ShouldPulseNetwork x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_ShouldPulseNetwork(
    Device self
);

bool CanOverrideNetworkContext() overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "CanOverrideNetworkContext;",
    (Device_CanOverrideNetworkContext x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_CanOverrideNetworkContext(
    Device self
);

bool IsNetworkKnownToPlayer() overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "IsNetworkKnownToPlayer;",
    (Device_IsNetworkKnownToPlayer x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_IsNetworkKnownToPlayer(
    Device self
);

bool OnPulseEvent(game.VisionModeUpdateVisuals evt) overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnPulseEvent",
    (Device_OnPulseEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnPulseEvent(
    Device self,
    game.VisionModeUpdateVisuals? evt
);

FocusForcedHighlightData? GetDefaultHighlight() overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetDefaultHighlight;",
    (Device_GetDefaultHighlight x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.FocusForcedHighlightData>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetDefaultHighlight(
    Device self
);

EFocusOutlineType GetCurrentOutline() overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetCurrentOutline;",
    (Device_GetCurrentOutline x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EFocusOutlineType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetCurrentOutline(
    Device self
);

DeviceConnectionsHighlightSystem? GetDeviceConnectionsHighlightSystem() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetDeviceConnectionsHighlightSystem;",
    (Device_GetDeviceConnectionsHighlightSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.DeviceConnectionsHighlightSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetDeviceConnectionsHighlightSystem(
    Device self
);

bool OnNotifyHighlightedDevice(NotifyHighlightedDevice evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnNotifyHighlightedDevice",
    (Device_OnNotifyHighlightedDevice x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnNotifyHighlightedDevice(
    Device self,
    NotifyHighlightedDevice? evt
);

bool NotifyConnectionHighlightSystem(bool IsHighlightON, bool IsNotifiedByMasterDevice) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "NotifyConnectionHighlightSystem;BoolBool",
    (Device_NotifyConnectionHighlightSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_NotifyConnectionHighlightSystem(
    Device self,
    bool IsHighlightON,
    bool IsNotifiedByMasterDevice
);

void SendSkillCheckInfo(bool display) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "SendSkillCheckInfo;Bool",
    (Device_SendSkillCheckInfo x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_SendSkillCheckInfo(
    Device self,
    bool display
);

void SendDisableAreaIndicatorEvent() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "SendDisableAreaIndicatorEvent;",
    (Device_SendDisableAreaIndicatorEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_SendDisableAreaIndicatorEvent(
    Device self
);

bool OnDisableAreaIndicator(DisableAreaIndicatorEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnDisableAreaIndicator",
    (Device_OnDisableAreaIndicator x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnDisableAreaIndicator(
    Device self,
    DisableAreaIndicatorEvent? evt
);

bool OnAreaEnter(ent.AreaEnteredEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnAreaEnter",
    (Device_OnAreaEnter x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnAreaEnter(
    Device self,
    ent.AreaEnteredEvent? evt
);

bool OnAreaExit(ent.AreaExitedEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnAreaExit",
    (Device_OnAreaExit x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnAreaExit(
    Device self,
    ent.AreaExitedEvent? evt
);

bool OnHitEvent(game.events.HitEvent hit) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnHitEvent",
    (Device_OnHitEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnHitEvent(
    Device self,
    game.events.HitEvent? hit
);

bool OnProjectileBreachEvent(ProjectileBreachEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnProjectileBreachEvent",
    (Device_OnProjectileBreachEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnProjectileBreachEvent(
    Device self,
    ProjectileBreachEvent? evt
);

void ProjectileExposeQuickHacks() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "ProjectileExposeQuickHacks;",
    (Device_ProjectileExposeQuickHacks x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_ProjectileExposeQuickHacks(
    Device self
);

bool OnDelayedDeviceOperation(DelayedOperationEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnDelayedDeviceOperation",
    (Device_OnDelayedDeviceOperation x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnDelayedDeviceOperation(
    Device self,
    DelayedOperationEvent? evt
);

bool OndDeviceOperationTriggerDelayed(DelayedDeviceOperationTriggerEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OndDeviceOperationTriggerDelayed",
    (Device_OndDeviceOperationTriggerDelayed x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OndDeviceOperationTriggerDelayed(
    Device self,
    DelayedDeviceOperationTriggerEvent? evt
);

bool OnPlayerDetectedVisibleEvent(sense.OnDetectedEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnPlayerDetectedVisibleEvent",
    (Device_OnPlayerDetectedVisibleEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnPlayerDetectedVisibleEvent(
    Device self,
    sense.OnDetectedEvent? evt
);

void ResolveDeviceOperationOnFocusMode(game.VisionModeType visionType, bool activated) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "ResolveDeviceOperationOnFocusMode;gameVisionModeTypeBool",
    (Device_ResolveDeviceOperationOnFocusMode x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_ResolveDeviceOperationOnFocusMode(
    Device self,
    game.VisionModeType visionType,
    bool activated
);

void RegisterPlayerTargetCallback() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "RegisterPlayerTargetCallback;",
    (Device_RegisterPlayerTargetCallback x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_RegisterPlayerTargetCallback(
    Device self
);

void UnRegisterPlayerTargetCallback() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "UnRegisterPlayerTargetCallback;",
    (Device_UnRegisterPlayerTargetCallback x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_UnRegisterPlayerTargetCallback(
    Device self
);

float GetCurrentHealth() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetCurrentHealth;",
    (Device_GetCurrentHealth x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetCurrentHealth(
    Device self
);

float GetTotalHealth() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetTotalHealth;",
    (Device_GetTotalHealth x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetTotalHealth(
    Device self
);

void ProcessDamagePipeline(game.events.HitEvent evt) overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "ProcessDamagePipeline;gameHitEvent",
    (Device_ProcessDamagePipeline x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_ProcessDamagePipeline(
    Device self,
    game.events.HitEvent? evt
);

void ApplyDamage(game.damage.AttackData attackData) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "ApplyDamage;AttackData",
    (Device_ApplyDamage x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_ApplyDamage(
    Device self,
    game.damage.AttackData? attackData
);

bool IsHighlightedInFocusMode() overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "IsHighlightedInFocusMode;",
    (Device_IsHighlightedInFocusMode x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_IsHighlightedInFocusMode(
    Device self
);

void TriggerAreaEffectDistractionByName(CName effectName) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "TriggerAreaEffectDistractionByName;CName",
    (Device_TriggerAreaEffectDistractionByName x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_TriggerAreaEffectDistractionByName(
    Device self,
    CName effectName
);

void TriggerAreaEffectDistractionByAction(ScriptableDeviceAction action) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "TriggerAreaEffectDistractionByAction;ScriptableDeviceAction",
    (Device_TriggerAreaEffectDistractionByAction x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_TriggerAreaEffectDistractionByAction(
    Device self,
    ScriptableDeviceAction? action
);

float GetAreaEffectLifetimeByName(CName effectName) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetAreaEffectLifetimeByName;CName",
    (Device_GetAreaEffectLifetimeByName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetAreaEffectLifetimeByName(
    Device self,
    CName effectName
);

float GetAreaEffectLifetimeByAction(ScriptableDeviceAction action) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetAreaEffectLifetimeByAction;ScriptableDeviceAction",
    (Device_GetAreaEffectLifetimeByAction x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetAreaEffectLifetimeByAction(
    Device self,
    ScriptableDeviceAction? action
);

float GetAreaEffectStimRangeByAction(ScriptableDeviceAction action) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetAreaEffectStimRangeByAction;ScriptableDeviceAction",
    (Device_GetAreaEffectStimRangeByAction x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetAreaEffectStimRangeByAction(
    Device self,
    ScriptableDeviceAction? action
);

AreaEffectData? GetDefaultDistractionAreaEffectData() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetDefaultDistractionAreaEffectData;",
    (Device_GetDefaultDistractionAreaEffectData x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.AreaEffectData>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetDefaultDistractionAreaEffectData(
    Device self
);

void TriggerArreaEffectDistraction(AreaEffectData effectData, game.Object? executor) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "TriggerArreaEffectDistraction;AreaEffectDataGameObject",
    (Device_TriggerArreaEffectDistraction x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_TriggerArreaEffectDistraction(
    Device self,
    AreaEffectData? effectData,
    game.Object? executor
);

Vector4[] GetNodePosition(NodeRef? nodeRef) RTTI
Vector4[] GetCachedInvestigationPositionsArray(world.GlobalNodeRef globalNodeRef) RTTI

void SetInvestigationPositionsArray(world.GlobalNodeRef globalNodeRef, Vector4[] arr) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "SetInvestigationPositionsArray;GlobalNodeRefscript_ref<array<Vector4>>",
    (Device_SetInvestigationPositionsArray x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_SetInvestigationPositionsArray(
    Device self,
    world.GlobalNodeRef globalNodeRef,
    List<Vector4> arr
);

bool HasInvestigationPositionsArrayCached(world.GlobalNodeRef globalNodeRef) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "HasInvestigationPositionsArrayCached;GlobalNodeRef",
    (Device_HasInvestigationPositionsArrayCached x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_HasInvestigationPositionsArrayCached(
    Device self,
    world.GlobalNodeRef globalNodeRef
);

Vector4 GetDistractionPointPosition(WeakHandle<game.Object> device) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetDistractionPointPosition;GameObject",
    (Device_GetDistractionPointPosition x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector4>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetDistractionPointPosition(
    Device self,
    WeakHandle<game.Object> device
);

bool CanBeInvestigated() overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "CanBeInvestigated;",
    (Device_CanBeInvestigated x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_CanBeInvestigated(
    Device self
);

bool IsInvestigated() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "IsInvestigated;",
    (Device_IsInvestigated x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_IsInvestigated(
    Device self
);

ent.EntityID[] GetWillingInvestigators() RTTI

bool OnUpdateWillingInvestigators(UpdateWillingInvestigators evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnUpdateWillingInvestigators",
    (Device_OnUpdateWillingInvestigators x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnUpdateWillingInvestigators(
    Device self,
    UpdateWillingInvestigators? evt
);

Vector4 CheckQueryStartPoint(WorldTransform transform) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "CheckQueryStartPoint;WorldTransform",
    (Device_CheckQueryStartPoint x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector4>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_CheckQueryStartPoint(
    Device self,
    WorldTransform transform
);

ent.Entity? GetEntityFromNode(NodeRef nodeRef) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetEntityFromNode;NodeRef",
    (Device_GetEntityFromNode x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ent.Entity>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetEntityFromNode(
    Device self,
    NodeRef nodeRef
);

game.Object? GetStimTarget() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetStimTarget;",
    (Device_GetStimTarget x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.GameObject>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetStimTarget(
    Device self
);

ent.Entity? GetDistractionControllerSource(AreaEffectData? effectData) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetDistractionControllerSource;AreaEffectData",
    (Device_GetDistractionControllerSource x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ent.Entity>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetDistractionControllerSource(
    Device self,
    AreaEffectData? effectData
);

float GetDistractionStimLifetime(float defaultValue) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetDistractionStimLifetime;Float",
    (Device_GetDistractionStimLifetime x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetDistractionStimLifetime(
    Device self,
    float defaultValue
);

NetworkBlackboardDef? GetNetworkBlackboardDef() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetNetworkBlackboardDef;",
    (Device_GetNetworkBlackboardDef x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.NetworkBlackboardDef>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetNetworkBlackboardDef(
    Device self
);

game.IBlackboard? GetNetworkBlackboard() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetNetworkBlackboard;",
    (Device_GetNetworkBlackboard x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.IBlackboard>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetNetworkBlackboard(
    Device self
);

bool OnToggleNetrunnerDive(ToggleNetrunnerDive evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnToggleNetrunnerDive",
    (Device_OnToggleNetrunnerDive x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnToggleNetrunnerDive(
    Device self,
    ToggleNetrunnerDive? evt
);

void PerformDive(int attempt, bool isRemote) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "PerformDive;Int32Bool",
    (Device_PerformDive x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_PerformDive(
    Device self,
    int attempt,
    bool isRemote
);

void TerminateConnection() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "TerminateConnection;",
    (Device_TerminateConnection x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_TerminateConnection(
    Device self
);

void DisplayConnectionWindowOnPlayerHUD(bool shouldDisplay, int attempt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "DisplayConnectionWindowOnPlayerHUD;BoolInt32",
    (Device_DisplayConnectionWindowOnPlayerHUD x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_DisplayConnectionWindowOnPlayerHUD(
    Device self,
    bool shouldDisplay,
    int attempt
);

void OnQuestMinigameRequest() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "OnQuestMinigameRequest;",
    (Device_OnQuestMinigameRequest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnQuestMinigameRequest(
    Device self
);

bool OnAccessPointMiniGameStatus(game.ui.AccessPointMiniGameStatus evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnAccessPointMiniGameStatus",
    (Device_OnAccessPointMiniGameStatus x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnAccessPointMiniGameStatus(
    Device self,
    game.ui.AccessPointMiniGameStatus? evt
);

bool OnSetExposeQuickHacks(SetExposeQuickHacks evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnSetExposeQuickHacks",
    (Device_OnSetExposeQuickHacks x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnSetExposeQuickHacks(
    Device self,
    SetExposeQuickHacks? evt
);

bool IsLookedAt() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "IsLookedAt;",
    (Device_IsLookedAt x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_IsLookedAt(
    Device self
);

Vector4 GetNetworkBeamOffset() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetNetworkBeamOffset;",
    (Device_GetNetworkBeamOffset x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector4>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetNetworkBeamOffset(
    Device self
);

CName GetNetworkLinkSlotName() overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetNetworkLinkSlotName;",
    (Device_GetNetworkLinkSlotName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetNetworkLinkSlotName(
    Device self
);

CName GetNetworkLinkSlotName(out WorldTransform transform) overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetNetworkLinkSlotName;WorldTransform",
    (Device_GetNetworkLinkSlotName2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetNetworkLinkSlotName2(
    Device self,
    WorldTransform transform
);

game.FxResource GetDefaultDevicesBeamResource() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetDefaultDevicesBeamResource;",
    (Device_GetDefaultDevicesBeamResource x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.FxResource>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetDefaultDevicesBeamResource(
    Device self
);

game.FxResource GetDefaultNetworkBeamResource() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetDefaultNetworkBeamResource;",
    (Device_GetDefaultNetworkBeamResource x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.FxResource>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetDefaultNetworkBeamResource(
    Device self
);

game.FxResource GetBreachedNetworkBeamResource() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetBreachedNetworkBeamResource;",
    (Device_GetBreachedNetworkBeamResource x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.FxResource>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetBreachedNetworkBeamResource(
    Device self
);

bool IsNetworkLinkDynamic() overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "IsNetworkLinkDynamic;",
    (Device_IsNetworkLinkDynamic x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_IsNetworkLinkDynamic(
    Device self
);

void RevealNetworkGrid_Event(bool shouldDraw, Vector4? ownerEntityPosition, game.FxResource? fxDefault, game.FxResource? fxBreached)

RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "RevealNetworkGrid_Event;BoolVector4FxResourceFxResource",
    (Device_RevealNetworkGrid_Event x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_RevealNetworkGrid_Event(
    Device self,
    bool shouldDraw,
    Vector4? ownerEntityPosition,
    game.FxResource? fxDefault,
    game.FxResource? fxBreached
);

void RevealDevicesGrid_Event(bool shouldDraw, Vector4? ownerEntityPosition, game.FxResource? fxDefault) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "RevealDevicesGrid_Event;BoolVector4FxResource",
    (Device_RevealDevicesGrid_Event x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_RevealDevicesGrid_Event(
    Device self,
    bool shouldDraw,
    Vector4? ownerEntityPosition,
    game.FxResource? fxDefault
);

void PingNetworkGrid_Event(Vector4 ownerEntityPosition, game.FxResource fxResource, float lifetime, EPingType pingType, bool revealSlave, bool revealMaster, bool ignoreRevealed)

RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "PingNetworkGrid_Event;Vector4FxResourceFloatEPingTypeBoolBoolBool",
    (Device_PingNetworkGrid_Event x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_PingNetworkGrid_Event(
    Device self,
    Vector4 ownerEntityPosition,
    game.FxResource fxResource,
    float lifetime,
    EPingType pingType,
    bool revealSlave,
    bool revealMaster,
    bool ignoreRevealed
);

void RevealNetworkGrid(bool shouldDraw) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "RevealNetworkGrid;Bool",
    (Device_RevealNetworkGrid x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_RevealNetworkGrid(
    Device self,
    bool shouldDraw
);

void PingNetworkGrid(float lifetime, EPingType pingType, bool revealSlave, bool revealMaster, bool ignoreRevealed) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "PingNetworkGrid;FloatEPingTypeBoolBoolBool",
    (Device_PingNetworkGrid x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_PingNetworkGrid(
    Device self,
    float lifetime,
    EPingType pingType,
    bool revealSlave,
    bool revealMaster,
    bool ignoreRevealed
);

void PingNetworkGrid(float lifetime, EPingType pingType, game.FxResource resource, bool revealSlave, bool revealMaster, bool ignoreRevealed)

RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "PingNetworkGrid;FloatEPingTypeFxResourceBoolBoolBool",
    (Device_PingNetworkGrid2 x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_PingNetworkGrid2(
    Device self,
    float lifetime,
    EPingType pingType,
    game.FxResource resource,
    bool revealSlave,
    bool revealMaster,
    bool ignoreRevealed
);

Vector4 GetNetworkBeamEndpoint() overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetNetworkBeamEndpoint;",
    (Device_GetNetworkBeamEndpoint x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector4>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetNetworkBeamEndpoint(
    Device self
);

void RevealDevicesGrid(bool shouldDraw) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "RevealDevicesGrid;Bool",
    (Device_RevealDevicesGrid x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_RevealDevicesGrid(
    Device self,
    bool shouldDraw
);

bool OnReavealDevicesGrid(RevealDevicesGridOnEntityEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnReavealDevicesGrid",
    (Device_OnReavealDevicesGrid x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnReavealDevicesGrid(
    Device self,
    RevealDevicesGridOnEntityEvent? evt
);

bool ShouldBeHighlightedLongerOnPing() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "ShouldBeHighlightedLongerOnPing;",
    (Device_ShouldBeHighlightedLongerOnPing x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_ShouldBeHighlightedLongerOnPing(
    Device self
);

bool OnRevealDeviceRequest(RevealDeviceRequest evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnRevealDeviceRequest",
    (Device_OnRevealDeviceRequest x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnRevealDeviceRequest(
    Device self,
    RevealDeviceRequest? evt
);

bool OnRevealNetworkGridRequestFromNetworkSystem(RevealNetworkGridNetworkRequest evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnRevealNetworkGridRequestFromNetworkSystem",
    (Device_OnRevealNetworkGridRequestFromNetworkSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnRevealNetworkGridRequestFromNetworkSystem(
    Device self,
    RevealNetworkGridNetworkRequest? evt
);

bool OnRevealNetworkGridOnPulse(RevealNetworkGridOnPulse evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnRevealNetworkGridOnPulse",
    (Device_OnRevealNetworkGridOnPulse x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnRevealNetworkGridOnPulse(
    Device self,
    RevealNetworkGridOnPulse? evt
);

bool OnRevealStateChanged(RevealStateChangedEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnRevealStateChanged",
    (Device_OnRevealStateChanged x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnRevealStateChanged(
    Device self,
    RevealStateChangedEvent? evt
);

void StartPingingNetwork() overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "StartPingingNetwork;",
    (Device_StartPingingNetwork x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_StartPingingNetwork(
    Device self
);

void StopPingingNetwork() overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "StopPingingNetwork;",
    (Device_StopPingingNetwork x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_StopPingingNetwork(
    Device self
);

bool OnActionPing(PingDevice evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnActionPing",
    (Device_OnActionPing x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnActionPing(
    Device self,
    PingDevice? evt
);

void PulseNetwork(bool revealNetworkAtEnd) overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "PulseNetwork;Bool",
    (Device_PulseNetwork x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_PulseNetwork(
    Device self,
    bool revealNetworkAtEnd
);

void ToggleAreaIndicator(bool turnOn) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "ToggleAreaIndicator;Bool",
    (Device_ToggleAreaIndicator x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_ToggleAreaIndicator(
    Device self,
    bool turnOn
);

bool OnTimetableEntryTriggered(DeviceTimetableEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnTimetableEntryTriggered",
    (Device_OnTimetableEntryTriggered x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnTimetableEntryTriggered(
    Device self,
    DeviceTimetableEvent? evt
);

bool OnToggleComponents(ToggleComponentsEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnToggleComponents",
    (Device_OnToggleComponents x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnToggleComponents(
    Device self,
    ToggleComponentsEvent? evt
);

void ResolveComponents(SComponentOperationData[] componentsData) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "ResolveComponents;script_ref<array<SComponentOperationData>>",
    (Device_ResolveComponents x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_ResolveComponents(
    Device self,
    SComponentOperationData[] componentsData
);

void ToggleComponentByName(CName componentName, bool toggle) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "ToggleComponentByName;CNameBool",
    (Device_ToggleComponentByName x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_ToggleComponentByName(
    Device self,
    CName componentName,
    bool toggle
);

bool OnPlayBink(PlayBinkEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnPlayBink",
    (Device_OnPlayBink x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnPlayBink(
    Device self,
    PlayBinkEvent? evt
);

game.FxResource GetFxResourceByKey(CName key) overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetFxResourceByKey;CName",
    (Device_GetFxResourceByKey x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.FxResource>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetFxResourceByKey(
    Device self,
    CName key
);

void AddHudButtonHelper(string argText, CName argIcon) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "AddHudButtonHelper;script_ref<String>CName",
    (Device_AddHudButtonHelper x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_AddHudButtonHelper(
    Device self,
    string argText,
    CName argIcon
);

void RemoveHudButtonHelper() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "RemoveHudButtonHelper;",
    (Device_RemoveHudButtonHelper x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_RemoveHudButtonHelper(
    Device self
);

bool OnFactChanged(game.FactChangedEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnFactChanged",
    (Device_OnFactChanged x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnFactChanged(
    Device self,
    game.FactChangedEvent? evt
);

bool IsTechie() overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "IsTechie;",
    (Device_IsTechie x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_IsTechie(
    Device self
);

bool IsSolo() overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "IsSolo;",
    (Device_IsSolo x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_IsSolo(
    Device self
);

bool IsNetrunner() overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "IsNetrunner;",
    (Device_IsNetrunner x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_IsNetrunner(
    Device self
);

bool IsCyberdeckEquippedOnPlayer() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "IsCyberdeckEquippedOnPlayer;",
    (Device_IsCyberdeckEquippedOnPlayer x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_IsCyberdeckEquippedOnPlayer(
    Device self
);

bool HasAnyPlaystyle() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "HasAnyPlaystyle;",
    (Device_HasAnyPlaystyle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_HasAnyPlaystyle(
    Device self
);

bool HasActiveStaticHackingSkillcheck() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "HasActiveStaticHackingSkillcheck;",
    (Device_HasActiveStaticHackingSkillcheck x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_HasActiveStaticHackingSkillcheck(
    Device self
);

bool HasAnySkillCheckActive() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "HasAnySkillCheckActive;",
    (Device_HasAnySkillCheckActive x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_HasAnySkillCheckActive(
    Device self
);

bool CanPassAnySkillCheck() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "CanPassAnySkillCheck;",
    (Device_CanPassAnySkillCheck x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_CanPassAnySkillCheck(
    Device self
);

bool CanPassAnySkillCheckOnMaster() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "CanPassAnySkillCheckOnMaster;",
    (Device_CanPassAnySkillCheckOnMaster x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_CanPassAnySkillCheckOnMaster(
    Device self
);

bool IsHackingSkillCheckActive() overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "IsHackingSkillCheckActive;",
    (Device_IsHackingSkillCheckActive x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_IsHackingSkillCheckActive(
    Device self
);

bool IsDemolitionSkillCheckActive() overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "IsDemolitionSkillCheckActive;",
    (Device_IsDemolitionSkillCheckActive x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_IsDemolitionSkillCheckActive(
    Device self
);

bool IsEngineeringSkillCheckActive() overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "IsEngineeringSkillCheckActive;",
    (Device_IsEngineeringSkillCheckActive x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_IsEngineeringSkillCheckActive(
    Device self
);

bool CanPassEngineeringSkillCheck() overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "CanPassEngineeringSkillCheck;",
    (Device_CanPassEngineeringSkillCheck x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_CanPassEngineeringSkillCheck(
    Device self
);

bool CanPassDemolitionSkillCheck() overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "CanPassDemolitionSkillCheck;",
    (Device_CanPassDemolitionSkillCheck x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_CanPassDemolitionSkillCheck(
    Device self
);

bool CanPassHackingSkillCheck() overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "CanPassHackingSkillCheck;",
    (Device_CanPassHackingSkillCheck x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_CanPassHackingSkillCheck(
    Device self
);

bool HasAnyQuickHackActive() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "HasAnyQuickHackActive;",
    (Device_HasAnyQuickHackActive x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_HasAnyQuickHackActive(
    Device self
);

bool HasAnyActiveQuickHackVulnerabilities() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "HasAnyActiveQuickHackVulnerabilities;",
    (Device_HasAnyActiveQuickHackVulnerabilities x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_HasAnyActiveQuickHackVulnerabilities(
    Device self
);

bool HasAnySpiderBotOrdersActive() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "HasAnySpiderBotOrdersActive;",
    (Device_HasAnySpiderBotOrdersActive x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_HasAnySpiderBotOrdersActive(
    Device self
);

bool HasAnyDistractions() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "HasAnyDistractions;",
    (Device_HasAnyDistractions x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_HasAnyDistractions(
    Device self
);

float GetDistractionRange(DeviceStimType type) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetDistractionRange;DeviceStimType",
    (Device_GetDistractionRange x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetDistractionRange(
    Device self,
    DeviceStimType type
);

float GetSmallestDistractionRange(DeviceStimType type) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetSmallestDistractionRange;DeviceStimType",
    (Device_GetSmallestDistractionRange x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetSmallestDistractionRange(
    Device self,
    DeviceStimType type
);

bool IsQuest() overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "IsQuest;",
    (Device_IsQuest x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_IsQuest(
    Device self
);

void MarkAsQuest(bool isQuest) overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "MarkAsQuest;Bool",
    (Device_MarkAsQuest x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_MarkAsQuest(
    Device self,
    bool isQuest
);

void ResolveQuestMarkOnFact() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "ResolveQuestMarkOnFact;",
    (Device_ResolveQuestMarkOnFact x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_ResolveQuestMarkOnFact(
    Device self
);

void ResolveQuestImportanceOnPerformedAction(ScriptableDeviceAction action) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "ResolveQuestImportanceOnPerformedAction;ScriptableDeviceAction",
    (Device_ResolveQuestImportanceOnPerformedAction x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_ResolveQuestImportanceOnPerformedAction(
    Device self,
    ScriptableDeviceAction? action
);

bool HasAnyNetworkLink() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "HasAnyNetworkLink;",
    (Device_HasAnyNetworkLink x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_HasAnyNetworkLink(
    Device self
);

bool HasAnyNetworkLink(bool ignorePingLinks) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "HasAnyNetworkLink;Bool",
    (Device_HasAnyNetworkLink2 x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_HasAnyNetworkLink2(
    Device self,
    bool ignorePingLinks
);

bool IsGameplayRoleValid(EGameplayRole role) overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "IsGameplayRoleValid;EGameplayRole",
    (Device_IsGameplayRoleValid x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_IsGameplayRoleValid(
    Device self,
    EGameplayRole role
);

bool IsActive() overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "IsActive;",
    (Device_IsActive x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_IsActive(
    Device self
);

bool IsGameplayRelevant() overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "IsGameplayRelevant;",
    (Device_IsGameplayRelevant x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_IsGameplayRelevant(
    Device self
);

TDBID GetContentScale() overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetContentScale;",
    (Device_GetContentScale x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.TDBID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetContentScale(
    Device self
);

EGameplayRole GetCurrentGameplayRole() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetCurrentGameplayRole;",
    (Device_GetCurrentGameplayRole x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EGameplayRole>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetCurrentGameplayRole(
    Device self
);

bool IsGameplayRoleStatic() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "IsGameplayRoleStatic;",
    (Device_IsGameplayRoleStatic x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_IsGameplayRoleStatic(
    Device self
);

void ReEvaluateGameplayRole() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "ReEvaluateGameplayRole;",
    (Device_ReEvaluateGameplayRole x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_ReEvaluateGameplayRole(
    Device self
);

void ForceReEvaluateGameplayRole() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "ForceReEvaluateGameplayRole;",
    (Device_ForceReEvaluateGameplayRole x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_ForceReEvaluateGameplayRole(
    Device self
);

EMappinVisualState DeterminGameplayRoleMappinVisuaState(SDeviceMappinData data) overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "DeterminGameplayRoleMappinVisuaState;script_ref<SDeviceMappinData>",
    (Device_DeterminGameplayRoleMappinVisuaState x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EMappinVisualState>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_DeterminGameplayRoleMappinVisuaState(
    Device self,
    SDeviceMappinData data
);

float DeterminGameplayRoleMappinRange(SDeviceMappinData data) overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "DeterminGameplayRoleMappinRange;script_ref<SDeviceMappinData>",
    (Device_DeterminGameplayRoleMappinRange x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_DeterminGameplayRoleMappinRange(
    Device self,
    SDeviceMappinData data
);

void ClearQuickHacks() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "ClearQuickHacks;",
    (Device_ClearQuickHacks x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_ClearQuickHacks(
    Device self
);

bool OnSetDeviceAttitude(SetDeviceAttitude evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnSetDeviceAttitude",
    (Device_OnSetDeviceAttitude x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnSetDeviceAttitude(
    Device self,
    SetDeviceAttitude? evt
);

bool OnQuickHackToggleOn(QuickHackToggleON evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnQuickHackToggleOn",
    (Device_OnQuickHackToggleOn x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnQuickHackToggleOn(
    Device self,
    QuickHackToggleON? evt
);

bool OnQuickHackDistraction(QuickHackDistraction evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnQuickHackDistraction",
    (Device_OnQuickHackDistraction x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnQuickHackDistraction(
    Device self,
    QuickHackDistraction? evt
);

bool OnQuestStartGlitch(QuestStartGlitch evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnQuestStartGlitch",
    (Device_OnQuestStartGlitch x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnQuestStartGlitch(
    Device self,
    QuestStartGlitch? evt
);

bool OnQuestStopGlitch(QuestStopGlitch evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnQuestStopGlitch",
    (Device_OnQuestStopGlitch x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnQuestStopGlitch(
    Device self,
    QuestStopGlitch? evt
);

bool OnGlitchScreen(GlitchScreen evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnGlitchScreen",
    (Device_OnGlitchScreen x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnGlitchScreen(
    Device self,
    GlitchScreen? evt
);

void StartGlitching(EGlitchState glitchState, float? intensity) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "StartGlitching;EGlitchStateFloat",
    (Device_StartGlitching x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_StartGlitching(
    Device self,
    EGlitchState glitchState,
    float? intensity
);

void StopGlitching() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "StopGlitching;",
    (Device_StopGlitching x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_StopGlitching(
    Device self
);

bool HasActiveDistraction() overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "HasActiveDistraction;",
    (Device_HasActiveDistraction x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_HasActiveDistraction(
    Device self
);

bool HasActiveQuickHackUpload() overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "HasActiveQuickHackUpload;",
    (Device_HasActiveQuickHackUpload x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_HasActiveQuickHackUpload(
    Device self
);

void SetGameplayRoleToNone() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "SetGameplayRoleToNone;",
    (Device_SetGameplayRoleToNone x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_SetGameplayRoleToNone(
    Device self
);

void SetGameplayRole(EGameplayRole role) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "SetGameplayRole;EGameplayRole",
    (Device_SetGameplayRole x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_SetGameplayRole(
    Device self,
    EGameplayRole role
);

Vector4 GetPlaystyleMappinSlotWorldPos() overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetPlaystyleMappinSlotWorldPos;",
    (Device_GetPlaystyleMappinSlotWorldPos x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector4>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetPlaystyleMappinSlotWorldPos(
    Device self
);

WorldTransform GetPlaystyleMappinSlotWorldTransform() overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetPlaystyleMappinSlotWorldTransform;",
    (Device_GetPlaystyleMappinSlotWorldTransform x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.WorldTransform>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetPlaystyleMappinSlotWorldTransform(
    Device self
);

Vector4 GetPlaystyleMappinLocalPos() overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetPlaystyleMappinLocalPos;",
    (Device_GetPlaystyleMappinLocalPos x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector4>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetPlaystyleMappinLocalPos(
    Device self
);

bool OnSpiderbotOrderCompletedEvent(SpiderbotOrderCompletedEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnSpiderbotOrderCompletedEvent",
    (Device_OnSpiderbotOrderCompletedEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnSpiderbotOrderCompletedEvent(
    Device self,
    SpiderbotOrderCompletedEvent? evt
);

void OrderSpiderbot() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "OrderSpiderbot;",
    (Device_OrderSpiderbot x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OrderSpiderbot(
    Device self
);

bool ShouldAllowSpiderbotToPerformAction() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "ShouldAllowSpiderbotToPerformAction;",
    (Device_ShouldAllowSpiderbotToPerformAction x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_ShouldAllowSpiderbotToPerformAction(
    Device self
);

bool OnSendSpiderbotToPerformActionEvent(SendSpiderbotToPerformActionEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnSendSpiderbotToPerformActionEvent",
    (Device_OnSendSpiderbotToPerformActionEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnSendSpiderbotToPerformActionEvent(
    Device self,
    SendSpiderbotToPerformActionEvent? evt
);

void SendSetIsSpiderbotInteractionOrderedEvent(bool value) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "SendSetIsSpiderbotInteractionOrderedEvent;Bool",
    (Device_SendSetIsSpiderbotInteractionOrderedEvent x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_SendSetIsSpiderbotInteractionOrderedEvent(
    Device self,
    bool value
);

ent.SlotComponent? GetSlotComponent() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetSlotComponent;",
    (Device_GetSlotComponent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ent.SlotComponent>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetSlotComponent(
    Device self
);

void InitializeGameplayObjectives() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "InitializeGameplayObjectives;",
    (Device_InitializeGameplayObjectives x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_InitializeGameplayObjectives(
    Device self
);

GameplayQuestSystem? GetGameplayQuestSystem() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetGameplayQuestSystem;",
    (Device_GetGameplayQuestSystem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.GameplayQuestSystem>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetGameplayQuestSystem(
    Device self
);

void ShowGameplayObjective(GemplayObjectiveData data) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "ShowGameplayObjective;GemplayObjectiveData",
    (Device_ShowGameplayObjective x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_ShowGameplayObjective(
    Device self,
    GemplayObjectiveData? data
);

void CreateGameplayObjective(GemplayObjectiveData data) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "CreateGameplayObjective;GemplayObjectiveData",
    (Device_CreateGameplayObjective x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_CreateGameplayObjective(
    Device self,
    GemplayObjectiveData? data
);

void SucceedGameplayObjective(GemplayObjectiveData data) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "SucceedGameplayObjective;GemplayObjectiveData",
    (Device_SucceedGameplayObjective x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_SucceedGameplayObjective(
    Device self,
    GemplayObjectiveData? data
);

void RemoveGameplayObjective(GemplayObjectiveData data) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "RemoveGameplayObjective;GemplayObjectiveData",
    (Device_RemoveGameplayObjective x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_RemoveGameplayObjective(
    Device self,
    GemplayObjectiveData? data
);

void ResolveGameplayObjectives(bool show) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "ResolveGameplayObjectives;Bool",
    (Device_ResolveGameplayObjectives x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_ResolveGameplayObjectives(
    Device self,
    bool show
);

bool OnCommunicationEvent(CommunicationEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnCommunicationEvent",
    (Device_OnCommunicationEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnCommunicationEvent(
    Device self,
    CommunicationEvent? evt
);

bool HasWillingInvestigator(ent.EntityID id) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "HasWillingInvestigator;EntityID",
    (Device_HasWillingInvestigator x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_HasWillingInvestigator(
    Device self,
    ent.EntityID id
);

void CheckDistractionAchievemnt() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "CheckDistractionAchievemnt;",
    (Device_CheckDistractionAchievemnt x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_CheckDistractionAchievemnt(
    Device self
);

void ApplyActiveStatusEffect(ent.EntityID target, TDBID statusEffect) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "ApplyActiveStatusEffect;EntityIDTweakDBID",
    (Device_ApplyActiveStatusEffect x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_ApplyActiveStatusEffect(
    Device self,
    ent.EntityID target,
    TDBID statusEffect
);

TDBID GetActiveStatusEffect() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetActiveStatusEffect;",
    (Device_GetActiveStatusEffect x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.TDBID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetActiveStatusEffect(
    Device self
);

void SetActiveStatusEffect(TDBID effect) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "SetActiveStatusEffect;TweakDBID",
    (Device_SetActiveStatusEffect x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_SetActiveStatusEffect(
    Device self,
    TDBID effect
);

void ClearActiveStatusEffect() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "ClearActiveStatusEffect;",
    (Device_ClearActiveStatusEffect x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_ClearActiveStatusEffect(
    Device self
);

bool IsActiveStatusEffectValid() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "IsActiveStatusEffectValid;",
    (Device_IsActiveStatusEffectValid x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_IsActiveStatusEffectValid(
    Device self
);

void SetActiveProgramToUploadOnNPC(TDBID program) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "SetActiveProgramToUploadOnNPC;TweakDBID",
    (Device_SetActiveProgramToUploadOnNPC x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_SetActiveProgramToUploadOnNPC(
    Device self,
    TDBID program
);

TDBID GetActiveProgramToUploadOnNPC() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetActiveProgramToUploadOnNPC;",
    (Device_GetActiveProgramToUploadOnNPC x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.TDBID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetActiveProgramToUploadOnNPC(
    Device self
);

void ClearActiveProgramToUploadOnNPC() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "ClearActiveProgramToUploadOnNPC;",
    (Device_ClearActiveProgramToUploadOnNPC x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_ClearActiveProgramToUploadOnNPC(
    Device self
);

bool IsActiveProgramToUploadOnNPCValid() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "IsActiveProgramToUploadOnNPCValid;",
    (Device_IsActiveProgramToUploadOnNPCValid x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_IsActiveProgramToUploadOnNPCValid(
    Device self
);

void UploadActiveProgramOnNPC(ent.EntityID targetID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "UploadActiveProgramOnNPC;EntityID",
    (Device_UploadActiveProgramOnNPC x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_UploadActiveProgramOnNPC(
    Device self,
    ent.EntityID targetID
);

bool OnQuestResolveSkillchecks(ResolveAllSkillchecksEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnQuestResolveSkillchecks",
    (Device_OnQuestResolveSkillchecks x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnQuestResolveSkillchecks(
    Device self,
    ResolveAllSkillchecksEvent? evt
);

bool OnQuestSetSkillchecks(SetSkillcheckEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnQuestSetSkillchecks",
    (Device_OnQuestSetSkillchecks x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnQuestSetSkillchecks(
    Device self,
    SetSkillcheckEvent? evt
);

bool OnChangeLoopCurveEvent(ChangeLoopCurveEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnChangeLoopCurveEvent",
    (Device_OnChangeLoopCurveEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnChangeLoopCurveEvent(
    Device self,
    ChangeLoopCurveEvent? evt
);

bool OnActionCooldownEvent(ActionCooldownEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnActionCooldownEvent",
    (Device_OnActionCooldownEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnActionCooldownEvent(
    Device self,
    ActionCooldownEvent? evt
);

bool OnDisableRPGRequirementsForQucikHackActions(DisableRPGRequirementsForDeviceActions evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnDisableRPGRequirementsForQucikHackActions",
    (Device_OnDisableRPGRequirementsForQucikHackActions x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnDisableRPGRequirementsForQucikHackActions(
    Device self,
    DisableRPGRequirementsForDeviceActions? evt
);

Vector4 GetAcousticQuerryStartPoint() overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetAcousticQuerryStartPoint;",
    (Device_GetAcousticQuerryStartPoint x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Vector4>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetAcousticQuerryStartPoint(
    Device self
);

bool OnReturnToDeviceScreenEvent(ReturnToDeviceScreenEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnReturnToDeviceScreenEvent",
    (Device_OnReturnToDeviceScreenEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnReturnToDeviceScreenEvent(
    Device self,
    ReturnToDeviceScreenEvent? evt
);

bool OnToggleTakeOverControl(ToggleTakeOverControl evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnToggleTakeOverControl",
    (Device_OnToggleTakeOverControl x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnToggleTakeOverControl(
    Device self,
    ToggleTakeOverControl? evt
);

bool OnTCSTakeOverControlActivate(TCSTakeOverControlActivate evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnTCSTakeOverControlActivate",
    (Device_OnTCSTakeOverControlActivate x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnTCSTakeOverControlActivate(
    Device self,
    TCSTakeOverControlActivate? evt
);

bool OnTCSTakeOverControlDeactivate(TCSTakeOverControlDeactivate evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnTCSTakeOverControlDeactivate",
    (Device_OnTCSTakeOverControlDeactivate x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnTCSTakeOverControlDeactivate(
    Device self,
    TCSTakeOverControlDeactivate? evt
);

void TakeControlOverCamera(bool isOn) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "TakeControlOverCamera;Bool",
    (Device_TakeControlOverCamera x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_TakeControlOverCamera(
    Device self,
    bool isOn
);

void HandlePlayerStateMachineZoom(float value) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "HandlePlayerStateMachineZoom;Float",
    (Device_HandlePlayerStateMachineZoom x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_HandlePlayerStateMachineZoom(
    Device self,
    float value
);

bool OnPlayerStateMachineZoom(float value) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnPlayerStateMachineZoom",
    (Device_OnPlayerStateMachineZoom x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnPlayerStateMachineZoom(
    Device self,
    float value
);

bool OnTCSInputXAxisEvent(TCSInputXAxisEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnTCSInputXAxisEvent",
    (Device_OnTCSInputXAxisEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnTCSInputXAxisEvent(
    Device self,
    TCSInputXAxisEvent? evt
);

bool OnTCSInputYAxisEvent(TCSInputYAxisEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnTCSInputYAxisEvent",
    (Device_OnTCSInputYAxisEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnTCSInputYAxisEvent(
    Device self,
    TCSInputYAxisEvent? evt
);

bool OnTCSInputXYAxisEvent(TCSInputXYAxisEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnTCSInputXYAxisEvent",
    (Device_OnTCSInputXYAxisEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnTCSInputXYAxisEvent(
    Device self,
    TCSInputXYAxisEvent? evt
);

bool OnTCSInputDeviceAttack(TCSInputDeviceAttack evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnTCSInputDeviceAttack",
    (Device_OnTCSInputDeviceAttack x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnTCSInputDeviceAttack(
    Device self,
    TCSInputDeviceAttack? evt
);

bool OnTCSInputCameraZoom(TCSInputCameraZoom evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnTCSInputCameraZoom",
    (Device_OnTCSInputCameraZoom x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnTCSInputCameraZoom(
    Device self,
    TCSInputCameraZoom? evt
);

bool ShouldRegisterToHUD() overrideRTTI

Generated hook

re.Hooks.Place(
    "Device",
    "ShouldRegisterToHUD;",
    (Device_ShouldRegisterToHUD x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_ShouldRegisterToHUD(
    Device self
);

bool OnOverloadDevice(OverloadDevice evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnOverloadDevice",
    (Device_OnOverloadDevice x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnOverloadDevice(
    Device self,
    OverloadDevice? evt
);

void StartOverload() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "StartOverload;",
    (Device_StartOverload x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_StartOverload(
    Device self
);

void StopOverload(float killDelay) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "StopOverload;Float",
    (Device_StopOverload x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_StopOverload(
    Device self,
    float killDelay
);

void KillNPCWorkspotUser(float killDelay) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "KillNPCWorkspotUser;Float",
    (Device_KillNPCWorkspotUser x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_KillNPCWorkspotUser(
    Device self,
    float killDelay
);

bool OnNPCKillDelayEvent(NPCKillDelayEvent evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnNPCKillDelayEvent",
    (Device_OnNPCKillDelayEvent x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnNPCKillDelayEvent(
    Device self,
    NPCKillDelayEvent? evt
);

void CreateEMPGameEffect(float range) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "CreateEMPGameEffect;Float",
    (Device_CreateEMPGameEffect x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_CreateEMPGameEffect(
    Device self,
    float range
);

void StopEMPGameEffect() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "StopEMPGameEffect;",
    (Device_StopEMPGameEffect x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_StopEMPGameEffect(
    Device self
);

void AddActiveContext(game.device.RequestType context) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "AddActiveContext;gamedeviceRequestType",
    (Device_AddActiveContext x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_AddActiveContext(
    Device self,
    game.device.RequestType context
);

void RemoveActiveContext(game.device.RequestType context) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "RemoveActiveContext;gamedeviceRequestType",
    (Device_RemoveActiveContext x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_RemoveActiveContext(
    Device self,
    game.device.RequestType context
);

void EvaluateProximityMappinInteractionLayerState() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "EvaluateProximityMappinInteractionLayerState;",
    (Device_EvaluateProximityMappinInteractionLayerState x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_EvaluateProximityMappinInteractionLayerState(
    Device self
);

void EnableProximityMappinInteractionLayer(bool enable) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "EnableProximityMappinInteractionLayer;Bool",
    (Device_EnableProximityMappinInteractionLayer x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_EnableProximityMappinInteractionLayer(
    Device self,
    bool enable
);

void ShowMappinOnProximity() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "ShowMappinOnProximity;",
    (Device_ShowMappinOnProximity x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_ShowMappinOnProximity(
    Device self
);

void HideMappinOnProximity() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "HideMappinOnProximity;",
    (Device_HideMappinOnProximity x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_HideMappinOnProximity(
    Device self
);

void EvaluateProximityRevealInteractionLayerState() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "EvaluateProximityRevealInteractionLayerState;",
    (Device_EvaluateProximityRevealInteractionLayerState x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_EvaluateProximityRevealInteractionLayerState(
    Device self
);

void EnableProximityRevealInteractionLayer(bool enable) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "EnableProximityRevealInteractionLayer;Bool",
    (Device_EnableProximityRevealInteractionLayer x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_EnableProximityRevealInteractionLayer(
    Device self,
    bool enable
);

void StartRevealingOnProximity() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "StartRevealingOnProximity;",
    (Device_StartRevealingOnProximity x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_StartRevealingOnProximity(
    Device self
);

void StopRevealingOnProximity(float lifetime) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "Device",
    "StopRevealingOnProximity;Float",
    (Device_StopRevealingOnProximity x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_StopRevealingOnProximity(
    Device self,
    float lifetime
);

float GetRevealOnProximityStopLifetimeValue() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetRevealOnProximityStopLifetimeValue;",
    (Device_GetRevealOnProximityStopLifetimeValue x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetRevealOnProximityStopLifetimeValue(
    Device self
);

game.FxInstance? CreateFxInstance(game.FxResource resource, WorldTransform transform) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "CreateFxInstance;FxResourceWorldTransform",
    (Device_CreateFxInstance x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.FxInstance>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_CreateFxInstance(
    Device self,
    game.FxResource resource,
    WorldTransform transform
);

bool OnHandleEngineeringSkillcheckSFX(ActionEngineering evt) RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "OnHandleEngineeringSkillcheckSFX",
    (Device_OnHandleEngineeringSkillcheckSFX x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_OnHandleEngineeringSkillcheckSFX(
    Device self,
    ActionEngineering? evt
);

CName GetEngineeringSkillcheckSFXName() RTTI

Generated hook

re.Hooks.Place(
    "Device",
    "GetEngineeringSkillcheckSFXName;",
    (Device_GetEngineeringSkillcheckSFXName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetEngineeringSkillcheckSFXName(
    Device self
);

static game.Object? GetPlayerMainObjectStatic(ScriptGameInstance context) staticRTTI global

Generated hook

re.Hooks.Place(
    "Device",
    "Device::GetPlayerMainObjectStatic;GameInstance",
    (Device_GetPlayerMainObjectStatic x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.GameObject>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_GetPlayerMainObjectStatic(
    ScriptGameInstance context
);

static game.device.Clearance? GetInteractionClearance() staticRTTI global

Generated hook

re.Hooks.Place(
    "Device",
    "Device::GetInteractionClearance;",
    (Device_GetInteractionClearance x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.device.Clearance>();
    }
);

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

static game.data.StimType MapStimType(DeviceStimType stim) staticRTTI global

Generated hook

re.Hooks.Place(
    "Device",
    "Device::MapStimType;DeviceStimType",
    (Device_MapStimType x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.StimType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct Device_MapStimType(
    DeviceStimType stim
);