class game

TransactionSystem

game.TransactionSystem

0 properties
89 functions

Extends game.ITransactionSystem game.IGameSystem IScriptable ISerializable

Properties

None.

Functions

void PrefetchItemAppearance(game.Object obj, game.ItemID itemID, CName newAppearanceName) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTransactionSystem",
    "PrefetchItemAppearance",
    (TransactionSystem_PrefetchItemAppearance x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_PrefetchItemAppearance(
    game.TransactionSystem self,
    game.Object? obj,
    game.ItemID itemID,
    CName newAppearanceName
);

void ChangeItemAppearanceByName(game.Object obj, game.ItemID itemID, CName newAppearanceName) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTransactionSystem",
    "ChangeItemAppearanceByName",
    (TransactionSystem_ChangeItemAppearanceByName x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_ChangeItemAppearanceByName(
    game.TransactionSystem self,
    game.Object? obj,
    game.ItemID itemID,
    CName newAppearanceName
);

void ChangeItemAppearanceByItemID(game.Object obj, game.ItemID itemID, game.ItemID newItemID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTransactionSystem",
    "ChangeItemAppearanceByItemID",
    (TransactionSystem_ChangeItemAppearanceByItemID x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_ChangeItemAppearanceByItemID(
    game.TransactionSystem self,
    game.Object? obj,
    game.ItemID itemID,
    game.ItemID newItemID
);

void ChangeItemAppearanceWithItemData() RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTransactionSystem",
    "ChangeItemAppearanceWithItemData",
    (TransactionSystem_ChangeItemAppearanceWithItemData x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_ChangeItemAppearanceWithItemData(
    game.TransactionSystem self
);

CName GetItemAppearance(game.Object obj, game.ItemID itemID) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "GetItemAppearance",
    (TransactionSystem_GetItemAppearance x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.CName>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_GetItemAppearance(
    game.TransactionSystem self,
    game.Object? obj,
    game.ItemID itemID
);

void ResetItemAppearance(game.Object obj, game.ItemID itemID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTransactionSystem",
    "ResetItemAppearance",
    (TransactionSystem_ResetItemAppearance x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_ResetItemAppearance(
    game.TransactionSystem self,
    game.Object? obj,
    game.ItemID itemID
);

void ClearAttachmentAppearance(game.Object obj, TDBID slotID) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTransactionSystem",
    "ClearAttachmentAppearance",
    (TransactionSystem_ClearAttachmentAppearance x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_ClearAttachmentAppearance(
    game.TransactionSystem self,
    game.Object? obj,
    TDBID slotID
);

bool RemoveMoney(game.Object obj, int amount, CName currency) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "RemoveMoney",
    (TransactionSystem_RemoveMoney x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_RemoveMoney(
    game.TransactionSystem self,
    game.Object? obj,
    int amount,
    CName currency
);

bool TransferMoney(game.Object source, game.Object target, int amount, CName currency) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "TransferMoney",
    (TransactionSystem_TransferMoney x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_TransferMoney(
    game.TransactionSystem self,
    game.Object? source,
    game.Object? target,
    int amount,
    CName currency
);

bool GiveMoney(game.Object target, int amount, CName currency) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "GiveMoney",
    (TransactionSystem_GiveMoney x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_GiveMoney(
    game.TransactionSystem self,
    game.Object? target,
    int amount,
    CName currency
);

bool RemoveItem(game.Object obj, game.ItemID itemID, int amount) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "RemoveItem",
    (TransactionSystem_RemoveItem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_RemoveItem(
    game.TransactionSystem self,
    game.Object? obj,
    game.ItemID itemID,
    int amount
);

bool RemoveItemByTDBID(game.Object obj, TDBID tdbID, int amount, bool? checkMultipleInstances) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "RemoveItemByTDBID",
    (TransactionSystem_RemoveItemByTDBID x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_RemoveItemByTDBID(
    game.TransactionSystem self,
    game.Object? obj,
    TDBID tdbID,
    int amount,
    bool? checkMultipleInstances
);

bool GiveItem(game.Object obj, game.ItemID itemID, int amount, CName[]? dynamicTags) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "GiveItem",
    (TransactionSystem_GiveItem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_GiveItem(
    game.TransactionSystem self,
    game.Object? obj,
    game.ItemID itemID,
    int amount,
    CName[]? dynamicTags
);

bool GiveItemByTDBID(game.Object obj, TDBID tdbID, int amount) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "GiveItemByTDBID",
    (TransactionSystem_GiveItemByTDBID x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_GiveItemByTDBID(
    game.TransactionSystem self,
    game.Object? obj,
    TDBID tdbID,
    int amount
);

bool GiveItems(game.Object obj, game.ItemModParams[] itemList) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "GiveItems",
    (TransactionSystem_GiveItems x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_GiveItems(
    game.TransactionSystem self,
    game.Object? obj,
    game.ItemModParams[] itemList
);

bool GiveItemByItemData(game.Object obj, game.ItemData itemData) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "GiveItemByItemData",
    (TransactionSystem_GiveItemByItemData x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_GiveItemByItemData(
    game.TransactionSystem self,
    game.Object? obj,
    game.ItemData? itemData
);

bool GivePreviewItemByItemData(game.Object obj, game.ItemData itemData) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "GivePreviewItemByItemData",
    (TransactionSystem_GivePreviewItemByItemData x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_GivePreviewItemByItemData(
    game.TransactionSystem self,
    game.Object? obj,
    game.ItemData? itemData
);

bool GivePreviewItemByItemID(game.Object obj, game.ItemID itemID) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "GivePreviewItemByItemID",
    (TransactionSystem_GivePreviewItemByItemID x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_GivePreviewItemByItemID(
    game.TransactionSystem self,
    game.Object? obj,
    game.ItemID itemID
);

game.ItemID CreatePreviewItemID(game.ItemID itemID) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "CreatePreviewItemID",
    (TransactionSystem_CreatePreviewItemID x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.ItemID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_CreatePreviewItemID(
    game.TransactionSystem self,
    game.ItemID itemID
);

bool GiveItemByItemQuery(game.Object obj, TDBID itemQueryTDBID, uint? amount, ulong? seed, string? telemetryLogSource) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "GiveItemByItemQuery",
    (TransactionSystem_GiveItemByItemQuery x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_GiveItemByItemQuery(
    game.TransactionSystem self,
    game.Object? obj,
    TDBID itemQueryTDBID,
    uint? amount,
    ulong? seed,
    string? telemetryLogSource
);

bool GiveItemByItemArrayQuery(game.Object obj, TDBID itemQueryTDBID, ulong? seed) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "GiveItemByItemArrayQuery",
    (TransactionSystem_GiveItemByItemArrayQuery x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_GiveItemByItemArrayQuery(
    game.TransactionSystem self,
    game.Object? obj,
    TDBID itemQueryTDBID,
    ulong? seed
);

game.data.Item_Record? RunItemQuery(TDBID itemQueryTDBID, game.Object? context, ulong? seed) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "RunItemQuery",
    (TransactionSystem_RunItemQuery x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.data.Item_Record>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_RunItemQuery(
    game.TransactionSystem self,
    TDBID itemQueryTDBID,
    game.Object? context,
    ulong? seed
);

void RunItemArrayQuery(out game.data.Item_Record[] itemRecords, TDBID itemQueryTDBID, TDBID[]? excludeItems, bool? uniquesOnly, game.Object? context, ulong? seed)

RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTransactionSystem",
    "RunItemArrayQuery",
    (TransactionSystem_RunItemArrayQuery x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_RunItemArrayQuery(
    game.TransactionSystem self,
    game.data.Item_Record[] itemRecords,
    TDBID itemQueryTDBID,
    TDBID[]? excludeItems,
    bool? uniquesOnly,
    game.Object? context,
    ulong? seed
);

bool TransferItem(game.Object source, game.Object target, game.ItemID itemID, int amount, CName[]? dynamicTags, bool? force, bool? flagItemAsSilent)

RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "TransferItem",
    (TransactionSystem_TransferItem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_TransferItem(
    game.TransactionSystem self,
    game.Object? source,
    game.Object? target,
    game.ItemID itemID,
    int amount,
    CName[]? dynamicTags,
    bool? force,
    bool? flagItemAsSilent
);

bool TransferAllItems(game.Object source, game.Object target) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "TransferAllItems",
    (TransactionSystem_TransferAllItems x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_TransferAllItems(
    game.TransactionSystem self,
    game.Object? source,
    game.Object? target
);

bool TakeItem(game.Object newOwner, WeakHandle<game.ItemObject> itemToLoot) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "TakeItem",
    (TransactionSystem_TakeItem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_TakeItem(
    game.TransactionSystem self,
    game.Object? newOwner,
    WeakHandle<game.ItemObject> itemToLoot
);

bool SellItem(game.Object seller, game.Object buyer, game.ItemID itemID, int amount, CName currency, int? price) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "SellItem",
    (TransactionSystem_SellItem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_SellItem(
    game.TransactionSystem self,
    game.Object? seller,
    game.Object? buyer,
    game.ItemID itemID,
    int amount,
    CName currency,
    int? price
);

bool SellItemStrict(game.Object seller, game.Object buyer, game.ItemID itemID, int amount, CName currency, int? price) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "SellItemStrict",
    (TransactionSystem_SellItemStrict x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_SellItemStrict(
    game.TransactionSystem self,
    game.Object? seller,
    game.Object? buyer,
    game.ItemID itemID,
    int amount,
    CName currency,
    int? price
);

bool HasItem(game.Object obj, game.ItemID itemID) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "HasItem",
    (TransactionSystem_HasItem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_HasItem(
    game.TransactionSystem self,
    game.Object? obj,
    game.ItemID itemID
);

bool HasTag(game.Object obj, CName tag, game.ItemID itemID) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "HasTag",
    (TransactionSystem_HasTag x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_HasTag(
    game.TransactionSystem self,
    game.Object? obj,
    CName tag,
    game.ItemID itemID
);

int GetItemQuantity(game.Object obj, game.ItemID itemID) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "GetItemQuantity",
    (TransactionSystem_GetItemQuantity x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_GetItemQuantity(
    game.TransactionSystem self,
    game.Object? obj,
    game.ItemID itemID
);

int GetItemQuantityWithDuplicates(game.Object obj, game.ItemID itemID) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "GetItemQuantityWithDuplicates",
    (TransactionSystem_GetItemQuantityWithDuplicates x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_GetItemQuantityWithDuplicates(
    game.TransactionSystem self,
    game.Object? obj,
    game.ItemID itemID
);

int GetItemQuantityByTag(game.Object obj, CName tag) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "GetItemQuantityByTag",
    (TransactionSystem_GetItemQuantityByTag x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_GetItemQuantityByTag(
    game.TransactionSystem self,
    game.Object? obj,
    CName tag
);

int GetTotalItemQuantity(game.Object obj) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "GetTotalItemQuantity",
    (TransactionSystem_GetTotalItemQuantity x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_GetTotalItemQuantity(
    game.TransactionSystem self,
    game.Object? obj
);

bool GetItemList(game.Object obj, out WeakHandle<game.ItemData>[] itemList) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "GetItemList",
    (TransactionSystem_GetItemList x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_GetItemList(
    game.TransactionSystem self,
    game.Object? obj,
    WeakHandle<game.ItemData>[] itemList
);

bool GetItemListByTag(game.Object obj, CName tag, out WeakHandle<game.ItemData>[] itemList) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "GetItemListByTag",
    (TransactionSystem_GetItemListByTag x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_GetItemListByTag(
    game.TransactionSystem self,
    game.Object? obj,
    CName tag,
    WeakHandle<game.ItemData>[] itemList
);

bool GetItemListByTags(game.Object obj, CName[] tagList, out WeakHandle<game.ItemData>[] itemList) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "GetItemListByTags",
    (TransactionSystem_GetItemListByTags x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_GetItemListByTags(
    game.TransactionSystem self,
    game.Object? obj,
    CName[] tagList,
    WeakHandle<game.ItemData>[] itemList
);

bool GetItemListExcludingTags(game.Object obj, CName[] tagList, out WeakHandle<game.ItemData>[] itemList) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "GetItemListExcludingTags",
    (TransactionSystem_GetItemListExcludingTags x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_GetItemListExcludingTags(
    game.TransactionSystem self,
    game.Object? obj,
    CName[] tagList,
    WeakHandle<game.ItemData>[] itemList
);

bool GetItemListFilteredByTags(game.Object obj, CName[] tags, CName[] excludedTags, out WeakHandle<game.ItemData>[] itemList)

RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "GetItemListFilteredByTags",
    (TransactionSystem_GetItemListFilteredByTags x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_GetItemListFilteredByTags(
    game.TransactionSystem self,
    game.Object? obj,
    CName[] tags,
    CName[] excludedTags,
    WeakHandle<game.ItemData>[] itemList
);

int GetNumItems(game.Object obj, CName[]? tagFilters) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "GetNumItems",
    (TransactionSystem_GetNumItems x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Int>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_GetNumItems(
    game.TransactionSystem self,
    game.Object? obj,
    CName[]? tagFilters
);

WeakHandle<game.ItemData> GetItemData(game.Object obj, game.ItemID itemID) RTTI
WeakHandle<game.ItemData> GetItemDataByTDBID(game.Object obj, TDBID itemTDBID) RTTI
WeakHandle<game.ItemData> GetItemDataByOwnerEntityId(ent.EntityID id, game.ItemID itemID) RTTI

bool InitializeSlots(game.Object obj, out TDBID[] slotIDList) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "InitializeSlots",
    (TransactionSystem_InitializeSlots x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_InitializeSlots(
    game.TransactionSystem self,
    game.Object? obj,
    TDBID[] slotIDList
);

void RefreshAttachment(game.Object obj, out TDBID slotID, bool? keepWorldTransform) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTransactionSystem",
    "RefreshAttachment",
    (TransactionSystem_RefreshAttachment x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_RefreshAttachment(
    game.TransactionSystem self,
    game.Object? obj,
    TDBID slotID,
    bool? keepWorldTransform
);

bool AddItemToSlot(game.Object obj, TDBID slotID, game.ItemID itemID, bool? highPriority, WeakHandle<game.ItemObject>? itemObject, ERenderingPlane? plane, bool? keepWorldTransform, bool? ignoreRestrictions, CName? garmentAppearanceName, game.ItemID? appearanceItem, bool? dontCacheEquippedItem)

RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "AddItemToSlot",
    (TransactionSystem_AddItemToSlot x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_AddItemToSlot(
    game.TransactionSystem self,
    game.Object? obj,
    TDBID slotID,
    game.ItemID itemID,
    bool? highPriority,
    WeakHandle<game.ItemObject>? itemObject,
    ERenderingPlane? plane,
    bool? keepWorldTransform,
    bool? ignoreRestrictions,
    CName? garmentAppearanceName,
    game.ItemID? appearanceItem,
    bool? dontCacheEquippedItem
);

bool DropItemFromSlot(game.Object obj, TDBID slotID, bool? shouldDestroyEntity, bool? keepWorldTransform, bool? skipSendAnimEquipEvents)

RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "DropItemFromSlot",
    (TransactionSystem_DropItemFromSlot x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_DropItemFromSlot(
    game.TransactionSystem self,
    game.Object? obj,
    TDBID slotID,
    bool? shouldDestroyEntity,
    bool? keepWorldTransform,
    bool? skipSendAnimEquipEvents
);

bool RemoveItemFromSlot(game.Object obj, TDBID slotID, bool? shouldDestroyEntity, bool? keepWorldTransform, bool? skipSendAnimEquipEvents)

RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "RemoveItemFromSlot",
    (TransactionSystem_RemoveItemFromSlot x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_RemoveItemFromSlot(
    game.TransactionSystem self,
    game.Object? obj,
    TDBID slotID,
    bool? shouldDestroyEntity,
    bool? keepWorldTransform,
    bool? skipSendAnimEquipEvents
);

bool RemoveItemFromAnySlot(game.Object obj, game.ItemID itemID, bool? shouldDestroyEntity, bool? keepWorldTransform) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "RemoveItemFromAnySlot",
    (TransactionSystem_RemoveItemFromAnySlot x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_RemoveItemFromAnySlot(
    game.TransactionSystem self,
    game.Object? obj,
    game.ItemID itemID,
    bool? shouldDestroyEntity,
    bool? keepWorldTransform
);

bool ChangeItemToSlot(game.Object obj, TDBID newSlotID, game.ItemID itemID) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "ChangeItemToSlot",
    (TransactionSystem_ChangeItemToSlot x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_ChangeItemToSlot(
    game.TransactionSystem self,
    game.Object? obj,
    TDBID newSlotID,
    game.ItemID itemID
);

bool IsSlotEmpty(game.Object obj, TDBID slotID) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "IsSlotEmpty",
    (TransactionSystem_IsSlotEmpty x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_IsSlotEmpty(
    game.TransactionSystem self,
    game.Object? obj,
    TDBID slotID
);

bool IsSlotEmptySpawningItem(game.Object obj, TDBID slotID) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "IsSlotEmptySpawningItem",
    (TransactionSystem_IsSlotEmptySpawningItem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_IsSlotEmptySpawningItem(
    game.TransactionSystem self,
    game.Object? obj,
    TDBID slotID
);

bool IsSlotSpawningItem(game.Object obj, TDBID slotID, game.ItemID itemID) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "IsSlotSpawningItem",
    (TransactionSystem_IsSlotSpawningItem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_IsSlotSpawningItem(
    game.TransactionSystem self,
    game.Object? obj,
    TDBID slotID,
    game.ItemID itemID
);

bool IsSlotSpawningAnyItem(game.Object obj, TDBID slotID) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "IsSlotSpawningAnyItem",
    (TransactionSystem_IsSlotSpawningAnyItem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_IsSlotSpawningAnyItem(
    game.TransactionSystem self,
    game.Object? obj,
    TDBID slotID
);

bool HasItemDataInSlot(game.Object obj, TDBID slotID, game.ItemID itemID) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "HasItemDataInSlot",
    (TransactionSystem_HasItemDataInSlot x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_HasItemDataInSlot(
    game.TransactionSystem self,
    game.Object? obj,
    TDBID slotID,
    game.ItemID itemID
);

bool HasItemInSlot(game.Object obj, TDBID slotID, game.ItemID itemID) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "HasItemInSlot",
    (TransactionSystem_HasItemInSlot x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_HasItemInSlot(
    game.TransactionSystem self,
    game.Object? obj,
    TDBID slotID,
    game.ItemID itemID
);

bool HasItemInAnySlot(game.Object obj, game.ItemID itemID) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "HasItemInAnySlot",
    (TransactionSystem_HasItemInAnySlot x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_HasItemInAnySlot(
    game.TransactionSystem self,
    game.Object? obj,
    game.ItemID itemID
);

bool CanPlaceItemInSlot(game.Object obj, TDBID slotID, game.ItemID itemID) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "CanPlaceItemInSlot",
    (TransactionSystem_CanPlaceItemInSlot x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_CanPlaceItemInSlot(
    game.TransactionSystem self,
    game.Object? obj,
    TDBID slotID,
    game.ItemID itemID
);

game.ItemObject? GetItemInSlot(game.Object obj, TDBID slotID) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "GetItemInSlot",
    (TransactionSystem_GetItemInSlot x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.ItemObject>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_GetItemInSlot(
    game.TransactionSystem self,
    game.Object? obj,
    TDBID slotID
);

game.ItemObject? GetItemInSlotByItemID(game.Object obj, game.ItemID itemID) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "GetItemInSlotByItemID",
    (TransactionSystem_GetItemInSlotByItemID x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.ItemObject>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_GetItemInSlotByItemID(
    game.TransactionSystem self,
    game.Object? obj,
    game.ItemID itemID
);

bool ClearAllSlots(game.Object obj) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "ClearAllSlots",
    (TransactionSystem_ClearAllSlots x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_ClearAllSlots(
    game.TransactionSystem self,
    game.Object? obj
);

game.ItemID CycleActiveItemInSlot(game.Object obj, TDBID slotID) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "CycleActiveItemInSlot",
    (TransactionSystem_CycleActiveItemInSlot x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.ItemID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_CycleActiveItemInSlot(
    game.TransactionSystem self,
    game.Object? obj,
    TDBID slotID
);

bool SetActiveItemInSlot(game.Object obj, TDBID slotID, game.ItemID itemID) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "SetActiveItemInSlot",
    (TransactionSystem_SetActiveItemInSlot x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_SetActiveItemInSlot(
    game.TransactionSystem self,
    game.Object? obj,
    TDBID slotID,
    game.ItemID itemID
);

bool EquipActiveItemInSlot(game.Object obj, TDBID slotID, bool highPriority) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "EquipActiveItemInSlot",
    (TransactionSystem_EquipActiveItemInSlot x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_EquipActiveItemInSlot(
    game.TransactionSystem self,
    game.Object? obj,
    TDBID slotID,
    bool highPriority
);

game.ItemID GetActiveItemInSlot(game.Object obj, TDBID slotID) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "GetActiveItemInSlot",
    (TransactionSystem_GetActiveItemInSlot x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.ItemID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_GetActiveItemInSlot(
    game.TransactionSystem self,
    game.Object? obj,
    TDBID slotID
);

bool CanItemBeActiveInSlot(game.Object obj, TDBID slotID, game.ItemID itemID) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "CanItemBeActiveInSlot",
    (TransactionSystem_CanItemBeActiveInSlot x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_CanItemBeActiveInSlot(
    game.TransactionSystem self,
    game.Object? obj,
    TDBID slotID,
    game.ItemID itemID
);

game.ItemID GetNextActiveItemInSlot(game.Object obj, TDBID slotID) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "GetNextActiveItemInSlot",
    (TransactionSystem_GetNextActiveItemInSlot x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.ItemID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_GetNextActiveItemInSlot(
    game.TransactionSystem self,
    game.Object? obj,
    TDBID slotID
);

game.ItemID RemovePart(game.Object obj, game.ItemID itemID, TDBID slotID, bool? shouldUpdateEntity) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "RemovePart",
    (TransactionSystem_RemovePart x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.ItemID>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_RemovePart(
    game.TransactionSystem self,
    game.Object? obj,
    game.ItemID itemID,
    TDBID slotID,
    bool? shouldUpdateEntity
);

bool AddPart(game.Object obj, game.ItemID itemID, game.ItemID partItemID, TDBID? slotID) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "AddPart",
    (TransactionSystem_AddPart x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_AddPart(
    game.TransactionSystem self,
    game.Object? obj,
    game.ItemID itemID,
    game.ItemID partItemID,
    TDBID? slotID
);

bool ForcePartInSlot(game.Object obj, game.ItemID itemID, game.ItemID partItemID, TDBID slotID) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "ForcePartInSlot",
    (TransactionSystem_ForcePartInSlot x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_ForcePartInSlot(
    game.TransactionSystem self,
    game.Object? obj,
    game.ItemID itemID,
    game.ItemID partItemID,
    TDBID slotID
);

void GetEmptySlotsOnItem(game.Object obj, game.ItemID itemID, out TDBID[] emptySlots) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTransactionSystem",
    "GetEmptySlotsOnItem",
    (TransactionSystem_GetEmptySlotsOnItem x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_GetEmptySlotsOnItem(
    game.TransactionSystem self,
    game.Object? obj,
    game.ItemID itemID,
    TDBID[] emptySlots
);

void GetAvailableSlotsOnItem(game.Object obj, game.ItemID itemID, out TDBID[] availableSlots) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTransactionSystem",
    "GetAvailableSlotsOnItem",
    (TransactionSystem_GetAvailableSlotsOnItem x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_GetAvailableSlotsOnItem(
    game.TransactionSystem self,
    game.Object? obj,
    game.ItemID itemID,
    TDBID[] availableSlots
);

void GetUsedSlotsOnItem(game.Object obj, game.ItemID itemID, out TDBID[] used) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTransactionSystem",
    "GetUsedSlotsOnItem",
    (TransactionSystem_GetUsedSlotsOnItem x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_GetUsedSlotsOnItem(
    game.TransactionSystem self,
    game.Object? obj,
    game.ItemID itemID,
    TDBID[] used
);

void GetItemsInstallableInSlot(game.Object obj, game.ItemID itemID, TDBID slotID, out game.ItemID[] installableItems) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTransactionSystem",
    "GetItemsInstallableInSlot",
    (TransactionSystem_GetItemsInstallableInSlot x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_GetItemsInstallableInSlot(
    game.TransactionSystem self,
    game.Object? obj,
    game.ItemID itemID,
    TDBID slotID,
    game.ItemID[] installableItems
);

game.StatsBundleHandler? CalculateTemporaryStatsBundle(game.Object obj, game.ItemID rootPartID, game.ItemID replacementPartID, TDBID slotIdForReplacement)

RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "CalculateTemporaryStatsBundle",
    (TransactionSystem_CalculateTemporaryStatsBundle x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.StatsBundleHandler>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_CalculateTemporaryStatsBundle(
    game.TransactionSystem self,
    game.Object? obj,
    game.ItemID rootPartID,
    game.ItemID replacementPartID,
    TDBID slotIdForReplacement
);

void ReinitializeStatsOnEntityItems(game.Object obj) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTransactionSystem",
    "ReinitializeStatsOnEntityItems",
    (TransactionSystem_ReinitializeStatsOnEntityItems x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_ReinitializeStatsOnEntityItems(
    game.TransactionSystem self,
    game.Object? obj
);

bool ReleaseItem(game.Object owner, WeakHandle<game.ItemObject> item) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "ReleaseItem",
    (TransactionSystem_ReleaseItem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_ReleaseItem(
    game.TransactionSystem self,
    game.Object? owner,
    WeakHandle<game.ItemObject> item
);

bool RemoveAllItems(game.Object obj) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "RemoveAllItems",
    (TransactionSystem_RemoveAllItems x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_RemoveAllItems(
    game.TransactionSystem self,
    game.Object? obj
);

bool ThrowItem(game.Object owner, WeakHandle<game.Object> item, game.projectile.SetUpAndLaunchEvent setUpAndLaunchEvent) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "ThrowItem",
    (TransactionSystem_ThrowItem x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_ThrowItem(
    game.TransactionSystem self,
    game.Object? owner,
    WeakHandle<game.Object> item,
    game.projectile.SetUpAndLaunchEvent? setUpAndLaunchEvent
);

game.InventoryScriptListener? RegisterInventoryListener(game.Object owner, game.InventoryScriptCallback callback) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "RegisterInventoryListener",
    (TransactionSystem_RegisterInventoryListener x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.InventoryScriptListener>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_RegisterInventoryListener(
    game.TransactionSystem self,
    game.Object? owner,
    game.InventoryScriptCallback? callback
);

game.AttachmentSlotsScriptListener? RegisterAttachmentSlotListener(game.Object owner, game.AttachmentSlotsScriptCallback callback)

RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "RegisterAttachmentSlotListener",
    (TransactionSystem_RegisterAttachmentSlotListener x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.game.AttachmentSlotsScriptListener>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_RegisterAttachmentSlotListener(
    game.TransactionSystem self,
    game.Object? owner,
    game.AttachmentSlotsScriptCallback? callback
);

void UnregisterInventoryListener(game.Object owner, game.InventoryScriptListener listener) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTransactionSystem",
    "UnregisterInventoryListener",
    (TransactionSystem_UnregisterInventoryListener x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_UnregisterInventoryListener(
    game.TransactionSystem self,
    game.Object? owner,
    game.InventoryScriptListener? listener
);

void UnregisterAttachmentSlotListener(game.Object owner, game.AttachmentSlotsScriptListener listener) RTTI

Generated hook

re.Hooks.PlaceVoid(
    "gameTransactionSystem",
    "UnregisterAttachmentSlotListener",
    (TransactionSystem_UnregisterAttachmentSlotListener x) =>
    {
        re.Hooks.CallOriginalVoid();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_UnregisterAttachmentSlotListener(
    game.TransactionSystem self,
    game.Object? owner,
    game.AttachmentSlotsScriptListener? listener
);

bool OnItemAddedToEquipmentSlot(game.Object owner, game.ItemID itemID, CName? garmentAppearanceName, game.ItemID? appearanceItem)

RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "OnItemAddedToEquipmentSlot",
    (TransactionSystem_OnItemAddedToEquipmentSlot x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_OnItemAddedToEquipmentSlot(
    game.TransactionSystem self,
    game.Object? owner,
    game.ItemID itemID,
    CName? garmentAppearanceName,
    game.ItemID? appearanceItem
);

bool OnItemRemovedFromEquipmentSlot(game.Object owner, game.ItemID itemID) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "OnItemRemovedFromEquipmentSlot",
    (TransactionSystem_OnItemRemovedFromEquipmentSlot x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_OnItemRemovedFromEquipmentSlot(
    game.TransactionSystem self,
    game.Object? owner,
    game.ItemID itemID
);

bool MatchVisualTag(ent.Entity entity, CName tag, bool? matchUsingDefaultAppearance) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "MatchVisualTag",
    (TransactionSystem_MatchVisualTag x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_MatchVisualTag(
    game.TransactionSystem self,
    ent.Entity? entity,
    CName tag,
    bool? matchUsingDefaultAppearance
);

bool MatchVisualTagByItemID(game.ItemID itemID, game.Object owner, CName tag) RTTI

Generated hook

re.Hooks.Place(
    "gameTransactionSystem",
    "MatchVisualTagByItemID",
    (TransactionSystem_MatchVisualTagByItemID x) =>
    {
        return re.Hooks.CallOriginal<re.msgpack.Bool>();
    }
);

[Msgpack.Gen]
public readonly partial record struct TransactionSystem_MatchVisualTagByItemID(
    game.TransactionSystem self,
    game.ItemID itemID,
    game.Object? owner,
    CName tag
);

CName[] GetVisualTags(ent.Entity entity, bool? matchUsingDefaultAppearance) RTTI
CName[] GetVisualTagsByItemID(game.ItemID itemID, game.Object owner) RTTI