class

DoorControllerPS

10 properties
146 functions
3 derived classes

Extends ScriptableDeviceComponentPS SharedGameplayPS game.DeviceComponentPS game.ComponentPS game.PersistentState IScriptable ISerializable

Derived

BunkerDoorControllerPS, MovableWallScreenControllerPS, WindowControllerPS

Properties

Property	Type	Offset
`doorProperties`	`DoorSetup`	`0x288`	scripted
`doorSkillChecks`	`EngDemoContainer?`	`0x2C8`	scripted
`isOpened`	`bool`	`0x2D8`	scripted
`isLocked`	`bool`	`0x2D9`	scripted
`isSealed`	`bool`	`0x2DA`	scripted
`alarmRaised`	`bool`	`0x2DB`	scripted
`isBusy`	`bool`	`0x2DC`	scripted
`isLiftDoor`	`bool`	`0x2DD`	scripted
`isPlayerAuthorised`	`bool`	`0x2DE`	scripted
`openingTokens`	`ent.EntityID[]`	`0x2E0`	scripted

Functions

bool OnInstantiated() overrideRTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "OnInstantiated",
    (DoorControllerPS_OnInstantiated x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_OnInstantiated(
    DoorControllerPS self
);

void Initialize() overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "DoorControllerPS",
    "Initialize;",
    (DoorControllerPS_Initialize x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_Initialize(
    DoorControllerPS self
);

void GameAttached() overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "DoorControllerPS",
    "GameAttached;",
    (DoorControllerPS_GameAttached x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_GameAttached(
    DoorControllerPS self
);

BaseSkillCheckContainer? GetSkillCheckContainerForSetup() overrideRTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "GetSkillCheckContainerForSetup;",
    (DoorControllerPS_GetSkillCheckContainerForSetup x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.BaseSkillCheckContainer>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_GetSkillCheckContainerForSetup(
    DoorControllerPS self
);

bool IsStatic() overrideRTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "IsStatic;",
    (DoorControllerPS_IsStatic x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_IsStatic(
    DoorControllerPS self
);

bool IsClosingAutomatically() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "IsClosingAutomatically;",
    (DoorControllerPS_IsClosingAutomatically x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_IsClosingAutomatically(
    DoorControllerPS self
);

ent.EntityID[] GetOpeningTokensList() RTTI

bool IsOpen() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "IsOpen;",
    (DoorControllerPS_IsOpen x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_IsOpen(
    DoorControllerPS self
);

bool IsLogicallyClosed() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "IsLogicallyClosed;",
    (DoorControllerPS_IsLogicallyClosed x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_IsLogicallyClosed(
    DoorControllerPS self
);

bool IsClosed() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "IsClosed;",
    (DoorControllerPS_IsClosed x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_IsClosed(
    DoorControllerPS self
);

bool IsLocked() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "IsLocked;",
    (DoorControllerPS_IsLocked x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_IsLocked(
    DoorControllerPS self
);

bool IsUnlocked() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "IsUnlocked;",
    (DoorControllerPS_IsUnlocked x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_IsUnlocked(
    DoorControllerPS self
);

bool IsSealed() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "IsSealed;",
    (DoorControllerPS_IsSealed x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_IsSealed(
    DoorControllerPS self
);

bool canPlayerToggleLockState() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "canPlayerToggleLockState;",
    (DoorControllerPS_canPlayerToggleLockState x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_canPlayerToggleLockState(
    DoorControllerPS self
);

bool canPlayerToggleSealState() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "canPlayerToggleSealState;",
    (DoorControllerPS_canPlayerToggleSealState x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_canPlayerToggleSealState(
    DoorControllerPS self
);

bool canPlayerRemotelyAuthorize() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "canPlayerRemotelyAuthorize;",
    (DoorControllerPS_canPlayerRemotelyAuthorize x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_canPlayerRemotelyAuthorize(
    DoorControllerPS self
);

EDoorType GetDoorType() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "GetDoorType;",
    (DoorControllerPS_GetDoorType x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EDoorType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_GetDoorType(
    DoorControllerPS self
);

EDoorType GetDoorTypeSideTwo() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "GetDoorTypeSideTwo;",
    (DoorControllerPS_GetDoorTypeSideTwo x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EDoorType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_GetDoorTypeSideTwo(
    DoorControllerPS self
);

EDoorType GetDoorTypeSideOne() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "GetDoorTypeSideOne;",
    (DoorControllerPS_GetDoorTypeSideOne x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EDoorType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_GetDoorTypeSideOne(
    DoorControllerPS self
);

EDoorSkillcheckSide GetDoorSkillcheckSide() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "GetDoorSkillcheckSide;",
    (DoorControllerPS_GetDoorSkillcheckSide x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EDoorSkillcheckSide>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_GetDoorSkillcheckSide(
    DoorControllerPS self
);

EDoorSkillcheckSide GetDoorAuthorizationSide() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "GetDoorAuthorizationSide;",
    (DoorControllerPS_GetDoorAuthorizationSide x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EDoorSkillcheckSide>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_GetDoorAuthorizationSide(
    DoorControllerPS self
);

EDoorTriggerSide GetDoorTriggerSide() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "GetDoorTriggerSide;",
    (DoorControllerPS_GetDoorTriggerSide x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EDoorTriggerSide>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_GetDoorTriggerSide(
    DoorControllerPS self
);

float GetOpeningSpeed() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "GetOpeningSpeed;",
    (DoorControllerPS_GetOpeningSpeed x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_GetOpeningSpeed(
    DoorControllerPS self
);

float GetOpeningTime() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "GetOpeningTime;",
    (DoorControllerPS_GetOpeningTime x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_GetOpeningTime(
    DoorControllerPS self
);

float GetStimRange() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "GetStimRange;",
    (DoorControllerPS_GetStimRange x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Float>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_GetStimRange(
    DoorControllerPS self
);

bool IsShutter() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "IsShutter;",
    (DoorControllerPS_IsShutter x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_IsShutter(
    DoorControllerPS self
);

bool IsLiftDoor() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "IsLiftDoor;",
    (DoorControllerPS_IsLiftDoor x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_IsLiftDoor(
    DoorControllerPS self
);

bool IsBusy() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "IsBusy;",
    (DoorControllerPS_IsBusy x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_IsBusy(
    DoorControllerPS self
);

TDBID GetPaymentRecordID() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "GetPaymentRecordID;",
    (DoorControllerPS_GetPaymentRecordID x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.TDBID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_GetPaymentRecordID(
    DoorControllerPS self
);

game.data.ActionPayment_Record? GetPaymentRecord() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "GetPaymentRecord;",
    (DoorControllerPS_GetPaymentRecord x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.ActionPayment_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_GetPaymentRecord(
    DoorControllerPS self
);

bool CanPayToUnlock() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "CanPayToUnlock;",
    (DoorControllerPS_CanPayToUnlock x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_CanPayToUnlock(
    DoorControllerPS self
);

bool ExposeQuickHakcsIfNotConnnectedToAP() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "ExposeQuickHakcsIfNotConnnectedToAP;",
    (DoorControllerPS_ExposeQuickHakcsIfNotConnnectedToAP x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_ExposeQuickHakcsIfNotConnnectedToAP(
    DoorControllerPS self
);

EDoorStatus GetDoorState() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "GetDoorState;",
    (DoorControllerPS_GetDoorState x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EDoorStatus>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_GetDoorState(
    DoorControllerPS self
);

bool IsSideOneActive() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "IsSideOneActive;",
    (DoorControllerPS_IsSideOneActive x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_IsSideOneActive(
    DoorControllerPS self
);

bool IsSideTwoActive() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "IsSideTwoActive;",
    (DoorControllerPS_IsSideTwoActive x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_IsSideTwoActive(
    DoorControllerPS self
);

DoorStatus? GetDeviceStatusAction() overrideRTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "GetDeviceStatusAction;",
    (DoorControllerPS_GetDeviceStatusAction x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.DoorStatus>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_GetDeviceStatusAction(
    DoorControllerPS self
);

void SetNewDoorType(EDoorType type) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "DoorControllerPS",
    "SetNewDoorType;EDoorType",
    (DoorControllerPS_SetNewDoorType x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_SetNewDoorType(
    DoorControllerPS self,
    EDoorType type
);

void SetTriggerSide(EDoorTriggerSide side) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "DoorControllerPS",
    "SetTriggerSide;EDoorTriggerSide",
    (DoorControllerPS_SetTriggerSide x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_SetTriggerSide(
    DoorControllerPS self,
    EDoorTriggerSide side
);

void SetIsOpened(bool isOpened) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "DoorControllerPS",
    "SetIsOpened;Bool",
    (DoorControllerPS_SetIsOpened x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_SetIsOpened(
    DoorControllerPS self,
    bool isOpened
);

void SetIsLocked(bool isLocked) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "DoorControllerPS",
    "SetIsLocked;Bool",
    (DoorControllerPS_SetIsLocked x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_SetIsLocked(
    DoorControllerPS self,
    bool isLocked
);

void SetIsSealed(bool isSealed) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "DoorControllerPS",
    "SetIsSealed;Bool",
    (DoorControllerPS_SetIsSealed x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_SetIsSealed(
    DoorControllerPS self,
    bool isSealed
);

void SetIsBusy(bool isBusy) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "DoorControllerPS",
    "SetIsBusy;Bool",
    (DoorControllerPS_SetIsBusy x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_SetIsBusy(
    DoorControllerPS self,
    bool isBusy
);

void InitializeDoorTypes() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "DoorControllerPS",
    "InitializeDoorTypes;",
    (DoorControllerPS_InitializeDoorTypes x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_InitializeDoorTypes(
    DoorControllerPS self
);

void SetDefaultDoorState() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "DoorControllerPS",
    "SetDefaultDoorState;",
    (DoorControllerPS_SetDefaultDoorState x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_SetDefaultDoorState(
    DoorControllerPS self
);

bool CheckIfLiftDoors() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "CheckIfLiftDoors;",
    (DoorControllerPS_CheckIfLiftDoors x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_CheckIfLiftDoors(
    DoorControllerPS self
);

bool IsLiftDoorAndAtThisFloor() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "IsLiftDoorAndAtThisFloor;",
    (DoorControllerPS_IsLiftDoorAndAtThisFloor x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_IsLiftDoorAndAtThisFloor(
    DoorControllerPS self
);

bool IsLiftFloorAuthorized() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "IsLiftFloorAuthorized;",
    (DoorControllerPS_IsLiftFloorAuthorized x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_IsLiftFloorAuthorized(
    DoorControllerPS self
);

bool IsLiftAvailable() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "IsLiftAvailable;",
    (DoorControllerPS_IsLiftAvailable x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_IsLiftAvailable(
    DoorControllerPS self
);

bool IsLiftUnauthorized() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "IsLiftUnauthorized;",
    (DoorControllerPS_IsLiftUnauthorized x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_IsLiftUnauthorized(
    DoorControllerPS self
);

bool IsLiftMoving() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "IsLiftMoving;",
    (DoorControllerPS_IsLiftMoving x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_IsLiftMoving(
    DoorControllerPS self
);

void PushResaveData(DoorResaveData data) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "DoorControllerPS",
    "PushResaveData;DoorResaveData",
    (DoorControllerPS_PushResaveData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_PushResaveData(
    DoorControllerPS self,
    DoorResaveData data
);

bool DetermineGameplayViability(game.GetActionsContext context, bool hasActiveActions) overrideRTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "DetermineGameplayViability;script_ref<GetActionsContext>Bool",
    (DoorControllerPS_DetermineGameplayViability x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_DetermineGameplayViability(
    DoorControllerPS self,
    game.GetActionsContext context,
    bool hasActiveActions
);

TDBID GetInkWidgetTweakDBID(game.GetActionsContext context) overrideRTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "GetInkWidgetTweakDBID;script_ref<GetActionsContext>",
    (DoorControllerPS_GetInkWidgetTweakDBID x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.TDBID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_GetInkWidgetTweakDBID(
    DoorControllerPS self,
    game.GetActionsContext context
);

CName GetWidgetTypeName() overrideRTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "GetWidgetTypeName",
    (DoorControllerPS_GetWidgetTypeName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_GetWidgetTypeName(
    DoorControllerPS self
);

string GetDeviceIconPath() overrideRTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "GetDeviceIconPath",
    (DoorControllerPS_GetDeviceIconPath x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Str>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_GetDeviceIconPath(
    DoorControllerPS self
);

TDBID GetDeviceIconTweakDBID() overrideRTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "GetDeviceIconTweakDBID;",
    (DoorControllerPS_GetDeviceIconTweakDBID x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.TDBID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_GetDeviceIconTweakDBID(
    DoorControllerPS self
);

TDBID GetBackgroundTextureTweakDBID() overrideRTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "GetBackgroundTextureTweakDBID;",
    (DoorControllerPS_GetBackgroundTextureTweakDBID x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.TDBID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_GetBackgroundTextureTweakDBID(
    DoorControllerPS self
);

EWidgetState GetWidgetVisualState() overrideRTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "GetWidgetVisualState;",
    (DoorControllerPS_GetWidgetVisualState x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EWidgetState>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_GetWidgetVisualState(
    DoorControllerPS self
);

bool GetActions(out game.device.Action[] actions, game.GetActionsContext context) overrideRTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "GetActions;array<DeviceAction>GetActionsContext",
    (DoorControllerPS_GetActions x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_GetActions(
    DoorControllerPS self,
    game.device.Action[] actions,
    game.GetActionsContext context
);

ToggleOpen? GetPlayerToggleOpenAction() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "GetPlayerToggleOpenAction;",
    (DoorControllerPS_GetPlayerToggleOpenAction x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ToggleOpen>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_GetPlayerToggleOpenAction(
    DoorControllerPS self
);

bool CanAddToggleOpenAction(game.GetActionsContext context) RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "CanAddToggleOpenAction;GetActionsContext",
    (DoorControllerPS_CanAddToggleOpenAction x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_CanAddToggleOpenAction(
    DoorControllerPS self,
    game.GetActionsContext context
);

void SetInactiveActionsWithExceptions(out game.device.Action[] outActions) overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "DoorControllerPS",
    "SetInactiveActionsWithExceptions;array<DeviceAction>",
    (DoorControllerPS_SetInactiveActionsWithExceptions x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_SetInactiveActionsWithExceptions(
    DoorControllerPS self,
    game.device.Action[] outActions
);

bool PushReturnActions(out game.device.Action[] outActions, game.GetActionsContext context) overrideRTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "PushReturnActions;array<DeviceAction>script_ref<GetActionsContext>",
    (DoorControllerPS_PushReturnActions x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_PushReturnActions(
    DoorControllerPS self,
    game.device.Action[] outActions,
    game.GetActionsContext context
);

bool CanCreateAnyQuickHackActions() overrideRTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "CanCreateAnyQuickHackActions;",
    (DoorControllerPS_CanCreateAnyQuickHackActions x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_CanCreateAnyQuickHackActions(
    DoorControllerPS self
);

void GetQuickHackActions(out game.device.Action[] actions, game.GetActionsContext context) overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "DoorControllerPS",
    "GetQuickHackActions;array<DeviceAction>script_ref<GetActionsContext>",
    (DoorControllerPS_GetQuickHackActions x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_GetQuickHackActions(
    DoorControllerPS self,
    game.device.Action[] actions,
    game.GetActionsContext context
);

void GetMinigameActions(game.device.Action[] actions, game.GetActionsContext context) overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "DoorControllerPS",
    "GetMinigameActions;script_ref<array<DeviceAction>>script_ref<GetActionsContext>",
    (DoorControllerPS_GetMinigameActions x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_GetMinigameActions(
    DoorControllerPS self,
    game.device.Action[] actions,
    game.GetActionsContext context
);

game.device.Action? GetQuestActionByName(CName actionName) overrideRTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "GetQuestActionByName;CName",
    (DoorControllerPS_GetQuestActionByName x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.device.Action>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_GetQuestActionByName(
    DoorControllerPS self,
    CName actionName
);

void GetQuestActions(out game.device.Action[] actions, game.GetActionsContext context) overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "DoorControllerPS",
    "GetQuestActions;array<DeviceAction>script_ref<GetActionsContext>",
    (DoorControllerPS_GetQuestActions x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_GetQuestActions(
    DoorControllerPS self,
    game.device.Action[] actions,
    game.GetActionsContext context
);

bool PushSkillCheckActions(out game.device.Action[] outActions, game.GetActionsContext context) overrideRTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "PushSkillCheckActions;array<DeviceAction>script_ref<GetActionsContext>",
    (DoorControllerPS_PushSkillCheckActions x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_PushSkillCheckActions(
    DoorControllerPS self,
    game.device.Action[] outActions,
    game.GetActionsContext context
);

bool IsTriggerValid(EDoorSkillcheckSide side) RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "IsTriggerValid;EDoorSkillcheckSide",
    (DoorControllerPS_IsTriggerValid x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_IsTriggerValid(
    DoorControllerPS self,
    EDoorSkillcheckSide side
);

DoorStatus? ActionDoorStatus() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "ActionDoorStatus;",
    (DoorControllerPS_ActionDoorStatus x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.DoorStatus>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_ActionDoorStatus(
    DoorControllerPS self
);

DoorOpeningToken? ActionDoorOpeningToken() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "ActionDoorOpeningToken;",
    (DoorControllerPS_ActionDoorOpeningToken x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.DoorOpeningToken>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_ActionDoorOpeningToken(
    DoorControllerPS self
);

EntityNotificationType OnDoorOpeningToken(DoorOpeningToken evt) RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "OnDoorOpeningToken;DoorOpeningToken",
    (DoorControllerPS_OnDoorOpeningToken x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EntityNotificationType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_OnDoorOpeningToken(
    DoorControllerPS self,
    DoorOpeningToken? evt
);

ToggleOpen? ActionToggleOpen() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "ActionToggleOpen;",
    (DoorControllerPS_ActionToggleOpen x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ToggleOpen>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_ActionToggleOpen(
    DoorControllerPS self
);

EntityNotificationType OnSecuritySystemOutput(SecuritySystemOutput evt) overrideRTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "OnSecuritySystemOutput;SecuritySystemOutput",
    (DoorControllerPS_OnSecuritySystemOutput x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EntityNotificationType>();
    }
);

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

EntityNotificationType OnToggleOpen(ToggleOpen evt) RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "OnToggleOpen;ToggleOpen",
    (DoorControllerPS_OnToggleOpen x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EntityNotificationType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_OnToggleOpen(
    DoorControllerPS self,
    ToggleOpen? evt
);

void OnSetIsOpened() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "DoorControllerPS",
    "OnSetIsOpened;",
    (DoorControllerPS_OnSetIsOpened x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_OnSetIsOpened(
    DoorControllerPS self
);

void OnDoorCollision() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "DoorControllerPS",
    "OnDoorCollision;",
    (DoorControllerPS_OnDoorCollision x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_OnDoorCollision(
    DoorControllerPS self
);

SetOpened? ActionSetOpened() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "ActionSetOpened;",
    (DoorControllerPS_ActionSetOpened x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.SetOpened>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_ActionSetOpened(
    DoorControllerPS self
);

EntityNotificationType OnSetOpened(SetOpened evt) RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "OnSetOpened;SetOpened",
    (DoorControllerPS_OnSetOpened x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EntityNotificationType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_OnSetOpened(
    DoorControllerPS self,
    SetOpened? evt
);

SetClosed? ActionSetClosed() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "ActionSetClosed;",
    (DoorControllerPS_ActionSetClosed x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.SetClosed>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_ActionSetClosed(
    DoorControllerPS self
);

EntityNotificationType OnSetClosed(SetClosed evt) RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "OnSetClosed;SetClosed",
    (DoorControllerPS_OnSetClosed x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EntityNotificationType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_OnSetClosed(
    DoorControllerPS self,
    SetClosed? evt
);

Pay? ActionPay(game.GetActionsContext context) overrideRTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "ActionPay;script_ref<GetActionsContext>",
    (DoorControllerPS_ActionPay x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Pay>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_ActionPay(
    DoorControllerPS self,
    game.GetActionsContext context
);

EntityNotificationType OnPay(Pay evt) RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "OnPay;Pay",
    (DoorControllerPS_OnPay x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EntityNotificationType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_OnPay(
    DoorControllerPS self,
    Pay? evt
);

QuickHackToggleOpen? ActionQuickHackToggleOpen() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "ActionQuickHackToggleOpen;",
    (DoorControllerPS_ActionQuickHackToggleOpen x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.QuickHackToggleOpen>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_ActionQuickHackToggleOpen(
    DoorControllerPS self
);

ToggleLock? ActionToggleLock() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "ActionToggleLock;",
    (DoorControllerPS_ActionToggleLock x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ToggleLock>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_ActionToggleLock(
    DoorControllerPS self
);

EntityNotificationType OnToggleLock(ToggleLock evt) RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "OnToggleLock;ToggleLock",
    (DoorControllerPS_OnToggleLock x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EntityNotificationType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_OnToggleLock(
    DoorControllerPS self,
    ToggleLock? evt
);

EntityNotificationType OnForceLockElevator(ForceLockElevator evt) RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "OnForceLockElevator;ForceLockElevator",
    (DoorControllerPS_OnForceLockElevator x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EntityNotificationType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_OnForceLockElevator(
    DoorControllerPS self,
    ForceLockElevator? evt
);

EntityNotificationType OnForceUnlockAndOpenElevator(ForceUnlockAndOpenElevator evt) RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "OnForceUnlockAndOpenElevator;ForceUnlockAndOpenElevator",
    (DoorControllerPS_OnForceUnlockAndOpenElevator x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EntityNotificationType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_OnForceUnlockAndOpenElevator(
    DoorControllerPS self,
    ForceUnlockAndOpenElevator? evt
);

ToggleSeal? ActionToggleSeal() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "ActionToggleSeal;",
    (DoorControllerPS_ActionToggleSeal x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ToggleSeal>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_ActionToggleSeal(
    DoorControllerPS self
);

EntityNotificationType OnToggleSeal(ToggleSeal evt) RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "OnToggleSeal;ToggleSeal",
    (DoorControllerPS_OnToggleSeal x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EntityNotificationType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_OnToggleSeal(
    DoorControllerPS self,
    ToggleSeal? evt
);

ActionDemolition? ActionDemolition(game.GetActionsContext context) overrideRTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "ActionDemolition;script_ref<GetActionsContext>",
    (DoorControllerPS_ActionDemolition x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ActionDemolition>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_ActionDemolition(
    DoorControllerPS self,
    game.GetActionsContext context
);

CallElevator? ActionCallElevator() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "ActionCallElevator;",
    (DoorControllerPS_ActionCallElevator x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CallElevator>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_ActionCallElevator(
    DoorControllerPS self
);

EntityNotificationType OnCallElevator(CallElevator evt) RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "OnCallElevator;CallElevator",
    (DoorControllerPS_OnCallElevator x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EntityNotificationType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_OnCallElevator(
    DoorControllerPS self,
    CallElevator? evt
);

bool IsPlayerCarrying() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "IsPlayerCarrying;",
    (DoorControllerPS_IsPlayerCarrying x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_IsPlayerCarrying(
    DoorControllerPS self
);

EntityNotificationType OnActionDemolition(ActionDemolition evt) overrideRTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "OnActionDemolition;ActionDemolition",
    (DoorControllerPS_OnActionDemolition x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EntityNotificationType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_OnActionDemolition(
    DoorControllerPS self,
    ActionDemolition? evt
);

EntityNotificationType OnActionEngineering(ActionEngineering evt) overrideRTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "OnActionEngineering;ActionEngineering",
    (DoorControllerPS_OnActionEngineering x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EntityNotificationType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_OnActionEngineering(
    DoorControllerPS self,
    ActionEngineering? evt
);

EntityNotificationType OnActionForceResetDevice(ActionForceResetDevice evt) overrideRTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "OnActionForceResetDevice;ActionForceResetDevice",
    (DoorControllerPS_OnActionForceResetDevice x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EntityNotificationType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_OnActionForceResetDevice(
    DoorControllerPS self,
    ActionForceResetDevice? evt
);

void ExecuteForceOpen(WeakHandle<game.Object> executor) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "DoorControllerPS",
    "ExecuteForceOpen;GameObject",
    (DoorControllerPS_ExecuteForceOpen x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_ExecuteForceOpen(
    DoorControllerPS self,
    WeakHandle<game.Object> executor
);

void RequestForceBodyDrop(WeakHandle<game.Object> executor) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "DoorControllerPS",
    "RequestForceBodyDrop;GameObject",
    (DoorControllerPS_RequestForceBodyDrop x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_RequestForceBodyDrop(
    DoorControllerPS self,
    WeakHandle<game.Object> executor
);

EntityNotificationType OnActionInstallKeylogger(InstallKeylogger evt) RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "OnActionInstallKeylogger;InstallKeylogger",
    (DoorControllerPS_OnActionInstallKeylogger x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EntityNotificationType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_OnActionInstallKeylogger(
    DoorControllerPS self,
    InstallKeylogger? evt
);

void ResolveOtherSkillchecks() overrideRTTI

Generated hook

re.Hooks.PlaceVoid(
    "DoorControllerPS",
    "ResolveOtherSkillchecks;",
    (DoorControllerPS_ResolveOtherSkillchecks x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_ResolveOtherSkillchecks(
    DoorControllerPS self
);

void ResolveSkillchecks() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "DoorControllerPS",
    "ResolveSkillchecks;",
    (DoorControllerPS_ResolveSkillchecks x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_ResolveSkillchecks(
    DoorControllerPS self
);

bool CanPassAnySkillCheckOnParentTerminal(game.Object requester) RTTI

Generated hook

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

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_CanPassAnySkillCheckOnParentTerminal(
    DoorControllerPS self,
    game.Object? requester
);

ForceOpen? ActionForceOpen() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "ActionForceOpen;",
    (DoorControllerPS_ActionForceOpen x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.ForceOpen>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_ActionForceOpen(
    DoorControllerPS self
);

EntityNotificationType OnForceOpen(ForceOpen evt) RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "OnForceOpen;ForceOpen",
    (DoorControllerPS_OnForceOpen x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EntityNotificationType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_OnForceOpen(
    DoorControllerPS self,
    ForceOpen? evt
);

QuestForceOpen? ActionQuestForceOpen() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "ActionQuestForceOpen;",
    (DoorControllerPS_ActionQuestForceOpen x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.QuestForceOpen>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_ActionQuestForceOpen(
    DoorControllerPS self
);

EntityNotificationType OnQuestForceOpen(QuestForceOpen evt) RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "OnQuestForceOpen;QuestForceOpen",
    (DoorControllerPS_OnQuestForceOpen x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EntityNotificationType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_OnQuestForceOpen(
    DoorControllerPS self,
    QuestForceOpen? evt
);

QuestForceClose? ActionQuestForceClose() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "ActionQuestForceClose;",
    (DoorControllerPS_ActionQuestForceClose x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.QuestForceClose>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_ActionQuestForceClose(
    DoorControllerPS self
);

EntityNotificationType OnQuestForceClose(QuestForceClose evt) RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "OnQuestForceClose;QuestForceClose",
    (DoorControllerPS_OnQuestForceClose x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EntityNotificationType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_OnQuestForceClose(
    DoorControllerPS self,
    QuestForceClose? evt
);

QuestForceCloseImmediate? ActionQuestForceCloseImmediate() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "ActionQuestForceCloseImmediate;",
    (DoorControllerPS_ActionQuestForceCloseImmediate x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.QuestForceCloseImmediate>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_ActionQuestForceCloseImmediate(
    DoorControllerPS self
);

EntityNotificationType OnQuestForceCloseImmediate(QuestForceCloseImmediate evt) RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "OnQuestForceCloseImmediate;QuestForceCloseImmediate",
    (DoorControllerPS_OnQuestForceCloseImmediate x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EntityNotificationType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_OnQuestForceCloseImmediate(
    DoorControllerPS self,
    QuestForceCloseImmediate? evt
);

QuestForceOpenScene? ActionQuestForceOpenScene() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "ActionQuestForceOpenScene;",
    (DoorControllerPS_ActionQuestForceOpenScene x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.QuestForceOpenScene>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_ActionQuestForceOpenScene(
    DoorControllerPS self
);

EntityNotificationType OnQuestForceOpenScene(QuestForceOpenScene evt) RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "OnQuestForceOpenScene;QuestForceOpenScene",
    (DoorControllerPS_OnQuestForceOpenScene x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EntityNotificationType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_OnQuestForceOpenScene(
    DoorControllerPS self,
    QuestForceOpenScene? evt
);

QuestForceCloseScene? ActionQuestForceCloseScene() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "ActionQuestForceCloseScene;",
    (DoorControllerPS_ActionQuestForceCloseScene x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.QuestForceCloseScene>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_ActionQuestForceCloseScene(
    DoorControllerPS self
);

EntityNotificationType OnQuestForceCloseScene(QuestForceCloseScene evt) RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "OnQuestForceCloseScene;QuestForceCloseScene",
    (DoorControllerPS_OnQuestForceCloseScene x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EntityNotificationType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_OnQuestForceCloseScene(
    DoorControllerPS self,
    QuestForceCloseScene? evt
);

QuestForceLock? ActionQuestForceLock() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "ActionQuestForceLock;",
    (DoorControllerPS_ActionQuestForceLock x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.QuestForceLock>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_ActionQuestForceLock(
    DoorControllerPS self
);

EntityNotificationType OnQuestForceLock(QuestForceLock evt) RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "OnQuestForceLock;QuestForceLock",
    (DoorControllerPS_OnQuestForceLock x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EntityNotificationType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_OnQuestForceLock(
    DoorControllerPS self,
    QuestForceLock? evt
);

QuestForceUnlock? ActionQuestForceUnlock() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "ActionQuestForceUnlock;",
    (DoorControllerPS_ActionQuestForceUnlock x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.QuestForceUnlock>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_ActionQuestForceUnlock(
    DoorControllerPS self
);

EntityNotificationType OnQuestForceUnlock(QuestForceUnlock evt) RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "OnQuestForceUnlock;QuestForceUnlock",
    (DoorControllerPS_OnQuestForceUnlock x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EntityNotificationType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_OnQuestForceUnlock(
    DoorControllerPS self,
    QuestForceUnlock? evt
);

QuestForceSeal? ActionQuestForceSeal() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "ActionQuestForceSeal;",
    (DoorControllerPS_ActionQuestForceSeal x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.QuestForceSeal>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_ActionQuestForceSeal(
    DoorControllerPS self
);

EntityNotificationType OnQuestForceSeal(QuestForceSeal evt) RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "OnQuestForceSeal;QuestForceSeal",
    (DoorControllerPS_OnQuestForceSeal x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EntityNotificationType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_OnQuestForceSeal(
    DoorControllerPS self,
    QuestForceSeal? evt
);

QuestForceUnseal? ActionQuestForceUnseal() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "ActionQuestForceUnseal;",
    (DoorControllerPS_ActionQuestForceUnseal x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.QuestForceUnseal>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_ActionQuestForceUnseal(
    DoorControllerPS self
);

EntityNotificationType OnQuestForceUnseal(QuestForceUnseal evt) RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "OnQuestForceUnseal;QuestForceUnseal",
    (DoorControllerPS_OnQuestForceUnseal x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EntityNotificationType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_OnQuestForceUnseal(
    DoorControllerPS self,
    QuestForceUnseal? evt
);

void SetNewDoorType(SetDoorType evt) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "DoorControllerPS",
    "SetNewDoorType;SetDoorType",
    (DoorControllerPS_SetNewDoorType2 x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_SetNewDoorType2(
    DoorControllerPS self,
    SetDoorType? evt
);

void SetCloseItself(bool val) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "DoorControllerPS",
    "SetCloseItself;Bool",
    (DoorControllerPS_SetCloseItself x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_SetCloseItself(
    DoorControllerPS self,
    bool val
);

void ResetToDefault() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "DoorControllerPS",
    "ResetToDefault;",
    (DoorControllerPS_ResetToDefault x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_ResetToDefault(
    DoorControllerPS self
);

void AccessGrantedNotification() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "DoorControllerPS",
    "AccessGrantedNotification;",
    (DoorControllerPS_AccessGrantedNotification x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_AccessGrantedNotification(
    DoorControllerPS self
);

EntityNotificationType OnSetAuthorizationModuleOFF(SetAuthorizationModuleOFF evt) overrideRTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "OnSetAuthorizationModuleOFF;SetAuthorizationModuleOFF",
    (DoorControllerPS_OnSetAuthorizationModuleOFF x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EntityNotificationType>();
    }
);

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

PlayerUnauthorized? ActionUnauthorized() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "ActionUnauthorized;",
    (DoorControllerPS_ActionUnauthorized x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.PlayerUnauthorized>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_ActionUnauthorized(
    DoorControllerPS self
);

void ResolveTerminalSkillchecks(ent.EntityID id) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "DoorControllerPS",
    "ResolveTerminalSkillchecks;EntityID",
    (DoorControllerPS_ResolveTerminalSkillchecks x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

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

EntityNotificationType OnQuickHackToggleOpen(QuickHackToggleOpen evt) RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "OnQuickHackToggleOpen;QuickHackToggleOpen",
    (DoorControllerPS_OnQuickHackToggleOpen x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EntityNotificationType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_OnQuickHackToggleOpen(
    DoorControllerPS self,
    QuickHackToggleOpen? evt
);

EntityNotificationType OnActivateDevice(ActivateDevice evt) overrideRTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "OnActivateDevice;ActivateDevice",
    (DoorControllerPS_OnActivateDevice x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EntityNotificationType>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_OnActivateDevice(
    DoorControllerPS self,
    ActivateDevice? evt
);

EntityNotificationType OnAuthorizeUser(AuthorizeUser evt) overrideRTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "OnAuthorizeUser;AuthorizeUser",
    (DoorControllerPS_OnAuthorizeUser x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.EntityNotificationType>();
    }
);

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

bool CanPayToAuthorize() overrideRTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "CanPayToAuthorize;",
    (DoorControllerPS_CanPayToAuthorize x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_CanPayToAuthorize(
    DoorControllerPS self
);

bool IsUserAuthorized(ent.EntityID user) overrideRTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "IsUserAuthorized;EntityID",
    (DoorControllerPS_IsUserAuthorized x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_IsUserAuthorized(
    DoorControllerPS self,
    ent.EntityID user
);

bool RequiresAuthorization() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "RequiresAuthorization;",
    (DoorControllerPS_RequiresAuthorization x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_RequiresAuthorization(
    DoorControllerPS self
);

void UpdatePlayerAuthorization() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "DoorControllerPS",
    "UpdatePlayerAuthorization;",
    (DoorControllerPS_UpdatePlayerAuthorization x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_UpdatePlayerAuthorization(
    DoorControllerPS self
);

bool WasPlayerAuthorized() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "WasPlayerAuthorized;",
    (DoorControllerPS_WasPlayerAuthorized x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_WasPlayerAuthorized(
    DoorControllerPS self
);

bool ToggleOpenOnDoor() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "ToggleOpenOnDoor;",
    (DoorControllerPS_ToggleOpenOnDoor x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_ToggleOpenOnDoor(
    DoorControllerPS self
);

bool ToggleLockOnDoor() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "ToggleLockOnDoor;",
    (DoorControllerPS_ToggleLockOnDoor x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_ToggleLockOnDoor(
    DoorControllerPS self
);

bool ToggleSealOnDoor() RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "ToggleSealOnDoor;",
    (DoorControllerPS_ToggleSealOnDoor x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_ToggleSealOnDoor(
    DoorControllerPS self
);

bool ShouldForceAuthorizeUser(game.GetActionsContext context) overrideRTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "ShouldForceAuthorizeUser;script_ref<GetActionsContext>",
    (DoorControllerPS_ShouldForceAuthorizeUser x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_ShouldForceAuthorizeUser(
    DoorControllerPS self,
    game.GetActionsContext context
);

void GiveKeycardsToExecutor(game.Object executor) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "DoorControllerPS",
    "GiveKeycardsToExecutor;GameObject",
    (DoorControllerPS_GiveKeycardsToExecutor x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct DoorControllerPS_GiveKeycardsToExecutor(
    DoorControllerPS self,
    game.Object? executor
);

bool AddToken(ent.EntityID id) RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "AddToken;EntityID",
    (DoorControllerPS_AddToken x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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

bool DepleteToken(ent.EntityID id) RTTI

Generated hook

re.Hooks.Place(
    "DoorControllerPS",
    "DepleteToken;EntityID",
    (DoorControllerPS_DepleteToken x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

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