isaacscript-common 10.0.0 → 10.1.0

package/src/features/saveDataManager/merge.ts

@@ -45,7 +45,6 @@ export function merge(
   newTable: LuaMap<AnyNotNil, unknown>,
   traversalDescription: string,
 ): void {
-  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
   if (SAVE_DATA_MANAGER_DEBUG) {
     log(`merge is traversing: ${traversalDescription}`);
   }
@@ -148,7 +147,6 @@ function mergeTable(
   iterateTableInOrder(
     newTable,
     (key, value) => {
-      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
       if (SAVE_DATA_MANAGER_DEBUG) {
         const valueToPrint = value === "" ? "(empty string)" : `${value}`;
         log(`merge is merging: ${traversalDescription} --> ${valueToPrint}`);
@@ -160,7 +158,6 @@ function mergeTable(
 
       // Handle the special case of serialized Isaac API classes.
       if (isSerializedIsaacAPIClass(value)) {
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
         if (SAVE_DATA_MANAGER_DEBUG) {
           log("merge found a serialized Isaac API class.");
         }

package/src/features/saveDataManager/saveDataManagerConstants.ts

@@ -1,4 +1,4 @@
 /** Set this to true to enable more verbosity in the save data manger. */
-export const SAVE_DATA_MANAGER_DEBUG = false;
+export const SAVE_DATA_MANAGER_DEBUG = false as boolean;
 
 export const SAVE_DATA_MANAGER_FEATURE_NAME = "save data manager";

package/src/functions/bitSet128.ts

@@ -1,10 +1,16 @@
+import { CopyableIsaacAPIClassType } from "isaac-typescript-definitions";
 import { SerializationBrand } from "../enums/private/SerializationBrand";
 import { isIsaacAPIClassOfType } from "./isaacAPIClass";
-import { copyValuesToTable, getNumbersFromTable, tableHasKeys } from "./table";
+import {
+  copyUserdataValuesToTable,
+  getNumbersFromTable,
+  tableHasKeys,
+} from "./table";
 import { isTable } from "./types";
 
 export type SerializedBitSet128 = LuaMap<string, unknown> & {
   readonly __serializedBitSet128Brand: symbol;
+  readonly __kind: CopyableIsaacAPIClassType.BIT_SET_128;
 };
 
 const OBJECT_NAME = "BitSet128";
@@ -86,7 +92,7 @@ export function serializeBitSet128(bitSet128: BitSet128): SerializedBitSet128 {
   }
 
   const bitSet128Table = new LuaMap<string, unknown>();
-  copyValuesToTable(bitSet128, KEYS, bitSet128Table);
+  copyUserdataValuesToTable(bitSet128, KEYS, bitSet128Table);
   bitSet128Table.set(SerializationBrand.BIT_SET_128, "");
   return bitSet128Table as SerializedBitSet128;
 }

package/src/functions/color.ts

@@ -1,12 +1,18 @@
+import { CopyableIsaacAPIClassType } from "isaac-typescript-definitions";
 import { SerializationBrand } from "../enums/private/SerializationBrand";
 import { isaacAPIClassEquals, isIsaacAPIClassOfType } from "./isaacAPIClass";
 import { getRandom } from "./random";
 import { getRandomSeed, isRNG, newRNG } from "./rng";
-import { copyValuesToTable, getNumbersFromTable, tableHasKeys } from "./table";
+import {
+  copyUserdataValuesToTable,
+  getNumbersFromTable,
+  tableHasKeys,
+} from "./table";
 import { isTable } from "./types";
 
 export type SerializedColor = LuaMap<string, unknown> & {
   readonly __serializedColorBrand: symbol;
+  readonly __kind: CopyableIsaacAPIClassType.COLOR;
 };
 
 const OBJECT_NAME = "Color";
@@ -120,7 +126,7 @@ export function serializeColor(color: Color): SerializedColor {
   }
 
   const colorTable = new LuaMap<string, unknown>();
-  copyValuesToTable(color, KEYS, colorTable);
+  copyUserdataValuesToTable(color, KEYS, colorTable);
   colorTable.set(SerializationBrand.COLOR, "");
   return colorTable as SerializedColor;
 }

package/src/functions/curses.ts

@@ -5,7 +5,7 @@ import { hasFlag } from "./flag";
 /**
  * Helper function to get the actual bit flag for modded curses.
  *
- * Will throw a runtime error if the provided curse does not exist.
+ * Will throw a run-time error if the provided curse does not exist.
  *
  * Use this over the `Isaac.GetCurseIdByName` method because that will return an integer instead of
  * a bit flag.

package/src/functions/deepCopy.ts

@@ -1,17 +1,16 @@
 import { DefaultMap } from "../classes/DefaultMap";
-import { CopyableIsaacAPIClassType } from "../enums/private/CopyableIsaacAPIClassType";
 import { SerializationBrand } from "../enums/private/SerializationBrand";
 import { SerializationType } from "../enums/SerializationType";
 import { SAVE_DATA_MANAGER_DEBUG } from "../features/saveDataManager/saveDataManagerConstants";
 import { isSerializationBrand } from "../features/saveDataManager/serializationBrands";
 import { TSTLClass } from "../types/TSTLClass";
 import { isArray } from "./array";
-import { getEnumValues } from "./enums";
 import { getIsaacAPIClassName } from "./isaacAPIClass";
 import { log } from "./log";
 import {
   copyIsaacAPIClass,
   deserializeIsaacAPIClass,
+  isCopyableIsaacAPIClass,
   isSerializedIsaacAPIClass,
   serializeIsaacAPIClass,
 } from "./serialization";
@@ -26,10 +25,6 @@ import {
 import { asString, isNumber, isPrimitive } from "./types";
 import { getTraversalDescription, twoDimensionalSort } from "./utils";
 
-const COPYABLE_ISAAC_API_CLASS_TYPES_SET = new Set<string>(
-  getEnumValues(CopyableIsaacAPIClassType),
-);
-
 /**
  * `deepCopy` is a semi-generic deep cloner. It will recursively copy all of the values so that none
  * of the nested references remain.
@@ -64,13 +59,24 @@ const COPYABLE_ISAAC_API_CLASS_TYPES_SET = new Set<string>(
  * @param insideMap Optional. Tracks whether or not the deep copy function is in the process of
  *                  recursively copying a TSTL Map. Default is false.
  */
+export function deepCopy<T>(
+  value: T,
+  serializationType?: SerializationType.NONE,
+  traversalDescription?: string,
+  insideMap?: boolean,
+): T;
+export function deepCopy(
+  value: unknown,
+  serializationType: SerializationType,
+  traversalDescription?: string,
+  insideMap?: boolean,
+): unknown; // The return types for serialization/deserialization are non-trivial, so we do not type them.
 export function deepCopy(
   value: unknown,
   serializationType = SerializationType.NONE,
   traversalDescription = "",
   insideMap = false,
 ): unknown {
-  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
   if (SAVE_DATA_MANAGER_DEBUG) {
     let logString = `deepCopy is operating on: ${traversalDescription}`;
     if (serializationType === SerializationType.SERIALIZE) {
@@ -101,6 +107,12 @@ export function deepCopy(
         );
       }
 
+      if (serializationType === SerializationType.DESERIALIZE) {
+        error(
+          `The deep copy function does not support deserialization of "${traversalDescription}", since it is type: ${valueType}`,
+        );
+      }
+
       // We cannot copy this, so simply return the reference.
       return value;
     }
@@ -126,7 +138,7 @@ function deepCopyTable(
   serializationType: SerializationType,
   traversalDescription: string,
   insideMap: boolean,
-) {
+): unknown {
   // First, handle the cases of TSTL classes or serialized TSTL classes.
   if (isDefaultMap(luaMap) || luaMap.has(SerializationBrand.DEFAULT_MAP)) {
     return deepCopyDefaultMap(
@@ -214,7 +226,6 @@ function deepCopyDefaultMap(
   traversalDescription: string,
   insideMap: boolean,
 ) {
-  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
   if (SAVE_DATA_MANAGER_DEBUG) {
     log("deepCopy is copying a DefaultMap.");
   }
@@ -346,7 +357,6 @@ function deepCopyMap(
   traversalDescription: string,
   insideMap: boolean,
 ) {
-  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
   if (SAVE_DATA_MANAGER_DEBUG) {
     log("deepCopy is copying a Map.");
   }
@@ -399,7 +409,6 @@ function deepCopySet(
   traversalDescription: string,
   insideMap: boolean,
 ) {
-  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
   if (SAVE_DATA_MANAGER_DEBUG) {
     log("deepCopy is copying a Set.");
   }
@@ -453,7 +462,6 @@ function deepCopyTSTLClass(
   traversalDescription: string,
   insideMap: boolean,
 ) {
-  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
   if (SAVE_DATA_MANAGER_DEBUG) {
     log("deepCopy is copying a TSTL class.");
   }
@@ -492,7 +500,6 @@ function deepCopyArray(
   traversalDescription: string,
   insideMap: boolean,
 ) {
-  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
   if (SAVE_DATA_MANAGER_DEBUG) {
     log("deepCopy is copying an array.");
   }
@@ -518,7 +525,6 @@ function deepCopyNormalLuaTable(
   traversalDescription: string,
   insideMap: boolean,
 ) {
-  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
   if (SAVE_DATA_MANAGER_DEBUG) {
     log("deepCopy is copying a normal Lua table.");
   }
@@ -568,7 +574,6 @@ function getCopiedEntries(
     }
   }
 
-  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
   if (SAVE_DATA_MANAGER_DEBUG) {
     entries.sort(twoDimensionalSort);
   }
@@ -651,11 +656,6 @@ function deepCopyUserdata(
   serializationType: SerializationType,
   traversalDescription: string,
 ) {
-  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-  if (SAVE_DATA_MANAGER_DEBUG) {
-    log("deepCopy is copying userdata.");
-  }
-
   const classType = getIsaacAPIClassName(value);
   if (classType === undefined) {
     error(
@@ -663,9 +663,9 @@ function deepCopyUserdata(
     );
   }
 
-  if (!COPYABLE_ISAAC_API_CLASS_TYPES_SET.has(classType)) {
+  if (!isCopyableIsaacAPIClass(value)) {
     error(
-      `The deep copy function does not support copying "${traversalDescription}", since it is an Isaac API class of type: ${classType}`,
+      `The deep copy function does not support serializing "${traversalDescription}", since it is an Isaac API class of type: ${classType}`,
     );
   }
 
@@ -679,7 +679,9 @@ function deepCopyUserdata(
     }
 
     case SerializationType.DESERIALIZE: {
-      return deserializeIsaacAPIClass(value);
+      error(
+        `The deep copy function can not deserialize "${traversalDescription}", since it is userdata.`,
+      );
     }
   }
 }

package/src/functions/deepCopyTests.ts

@@ -49,7 +49,7 @@ function copiedObjectIsTable() {
     abc: "def",
   };
   const newObject = deepCopy(
-    oldObject as unknown as LuaMap,
+    oldObject,
     SerializationType.NONE,
     "copiedObjectIsTable",
   );
@@ -64,12 +64,11 @@ function copiedObjectHasKeyAndValueString() {
   const oldObject = {
     abc: valueToLookFor,
   };
-  const newTable = deepCopy(
-    oldObject as unknown as LuaMap,
+  const newObject = deepCopy(
+    oldObject,
     SerializationType.NONE,
     "copiedObjectHasKeyAndValueString",
   );
-  const newObject = newTable as typeof oldObject;
 
   const value = newObject[keyToLookFor];
   // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
@@ -91,12 +90,11 @@ function copiedTableHasKeyAndValueNumber() {
   const oldTable = new LuaMap<AnyNotNil, unknown>();
   oldTable.set(keyToLookFor, valueToLookFor);
 
-  const newObject = deepCopy(
+  const newTable = deepCopy(
     oldTable,
     SerializationType.NONE,
     "copiedTableHasKeyAndValueNumber",
   );
-  const newTable = newObject as LuaMap<AnyNotNil, unknown>;
 
   const value = newTable.get(keyToLookFor) as number | undefined;
   if (value === undefined) {
@@ -117,12 +115,11 @@ function copiedTableDoesNotCoerceTypes() {
   const oldTable = new LuaMap<AnyNotNil, unknown>();
   oldTable.set(keyToLookFor, valueToLookFor);
 
-  const newObject = deepCopy(
+  const newTable = deepCopy(
     oldTable,
     SerializationType.NONE,
     "copiedTableDoesNotCoerceTypes",
   );
-  const newTable = newObject as LuaMap<AnyNotNil, unknown>;
 
   const keyString = tostring(keyToLookFor);
   const valueString = tostring(valueToLookFor);
@@ -148,12 +145,11 @@ function copiedObjectHasNoReferencesForPrimitivesForward() {
     abc: originalStringValue,
     def: originalNumberValue,
   };
-  const newTable = deepCopy(
-    oldObject as unknown as LuaMap,
+  const newObject = deepCopy(
+    oldObject,
     SerializationType.NONE,
     "copiedObjectHasNoReferencesForPrimitivesForward",
   );
-  const newObject = newTable as typeof oldObject;
 
   oldObject.abc = "newValue";
   if (oldObject.abc === newObject.abc) {
@@ -173,12 +169,11 @@ function copiedObjectHasNoReferencesForPrimitivesBackward() {
     abc: originalStringValue,
     def: originalNumberValue,
   };
-  const newTable = deepCopy(
-    oldObject as unknown as LuaMap,
+  const newObject = deepCopy(
+    oldObject,
     SerializationType.NONE,
     "copiedObjectHasNoReferencesForPrimitivesBackward",
   );
-  const newObject = newTable as typeof oldObject;
 
   newObject.abc = "newValue";
   if (newObject.abc === oldObject.abc) {
@@ -196,12 +191,11 @@ function copiedObjectHasNoReferencesForArray() {
   const oldObject = {
     abc: [1, 2, 3],
   };
-  const newTable = deepCopy(
-    oldObject as unknown as LuaMap,
+  const newObject = deepCopy(
+    oldObject,
     SerializationType.NONE,
     "copiedObjectHasNoReferencesForArray",
   );
-  const newObject = newTable as typeof oldObject;
 
   if (oldObject.abc === newObject.abc) {
     error("The copied object has the same point to the child array.");
@@ -237,12 +231,11 @@ function copiedObjectHasChildObject() {
       def: valueToLookFor,
     },
   };
-  const newTable = deepCopy(
-    oldObject as unknown as LuaMap,
+  const newObject = deepCopy(
+    oldObject,
     SerializationType.NONE,
     "copiedObjectHasChildObject",
   );
-  const newObject = newTable as typeof oldObject;
 
   const childObject = newObject[childObjectIndex];
   // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
@@ -274,8 +267,7 @@ function copiedMapIsMap() {
   const oldMap = new Map<string, string>();
   oldMap.set(keyToLookFor, valueToLookFor);
 
-  const newObject = deepCopy(oldMap, SerializationType.NONE, "copiedMapIsMap");
-  const newMap = newObject as Map<string, string>;
+  const newMap = deepCopy(oldMap, SerializationType.NONE, "copiedMapIsMap");
 
   if (!isTSTLMap(newMap)) {
     error(`The copied Map was not a Map and has a type of: ${typeof newMap}`);
@@ -288,13 +280,7 @@ function copiedMapHasValue() {
   const oldMap = new Map<string, string>();
   oldMap.set(keyToLookFor, valueToLookFor);
 
-  const newTable = deepCopy(
-    oldMap,
-    SerializationType.NONE,
-    "copiedMapHasValue",
-  );
-
-  const newMap = newTable as typeof oldMap;
+  const newMap = deepCopy(oldMap, SerializationType.NONE, "copiedMapHasValue");
 
   if (!isTSTLMap(newMap)) {
     error(`The copied Map was not a Map and has a type of: ${typeof newMap}`);
@@ -314,8 +300,7 @@ function copiedSetIsSet() {
   const oldSet = new Set<string>();
   oldSet.add(valueToLookFor);
 
-  const newTable = deepCopy(oldSet, SerializationType.NONE, "copiedSetIsSet");
-  const newSet = newTable as Set<string>;
+  const newSet = deepCopy(oldSet, SerializationType.NONE, "copiedSetIsSet");
 
   if (!isTSTLSet(newSet)) {
     error(`The copied Set was not a Set and has a type of: ${typeof newSet}`);
@@ -327,12 +312,7 @@ function copiedSetHasValue() {
   const oldSet = new Set<string>();
   oldSet.add(valueToLookFor);
 
-  const newTable = deepCopy(
-    oldSet,
-    SerializationType.NONE,
-    "copiedSetHasValue",
-  );
-  const newSet = newTable as Set<string>;
+  const newSet = deepCopy(oldSet, SerializationType.NONE, "copiedSetHasValue");
 
   if (!isTSTLSet(newSet)) {
     error(`The copied Set was not a Set and has a type of: ${typeof newSet}`);
@@ -354,12 +334,11 @@ function copiedMapHasChildMap() {
   const oldMap = new Map<string, Map<number, number>>();
   oldMap.set(keyToLookFor, oldChildMap);
 
-  const newTable = deepCopy(
+  const newMap = deepCopy(
     oldMap,
     SerializationType.NONE,
     "copiedMapHasChildMap",
   );
-  const newMap = newTable as typeof oldMap;
 
   if (!isTSTLMap(newMap)) {
     error(`The copied Map was not a Map and had a type of: ${typeof newMap}`);
@@ -398,12 +377,11 @@ function copiedDefaultMapHasChildDefaultMap() {
   oldChildMap.getAndSetDefault(childMapKey1);
   oldChildMap.set(childMapKey2, childMapCustomValue);
 
-  const newTable = deepCopy(
+  const newParentMap = deepCopy(
     oldParentMap,
     SerializationType.NONE,
     "copiedDefaultMapHasChildDefaultMap",
   );
-  const newParentMap = newTable as typeof oldParentMap;
 
   if (!isDefaultMap(newParentMap)) {
     error(

package/src/functions/doors.ts

@@ -259,7 +259,10 @@ export function getRoomShapeDoorSlotCoordinates(
   return coordinatesMap.get(doorSlot);
 }
 
-/** Helper function to find unused door slots in the room that can be used to make custom doors. */
+/**
+ * Helper function to find unused door slots in the current room that can be used to make custom
+ * doors.
+ */
 export function getUnusedDoorSlots(): DoorSlot[] {
   const room = game.GetRoom();
   const doorSlots = getEnumValues(DoorSlot);
@@ -269,6 +272,15 @@ export function getUnusedDoorSlots(): DoorSlot[] {
   );
 }
 
+/**
+ * Helper function to check if the current room has one or more open door slots that can be used to
+ * make custom doors.
+ */
+export function hasUnusedDoorSlot(): boolean {
+  const unusedDoorSlots = getUnusedDoorSlots();
+  return unusedDoorSlots.length > 0;
+}
+
 export function isAngelRoomDoor(door: GridEntityDoor): boolean {
   return door.TargetRoomType === RoomType.ANGEL;
 }

package/src/functions/initArray.ts

@@ -23,7 +23,7 @@ export function initArray<T>(defaultValue: T, size: int): T[] {
     if (isPrimitive(defaultValue)) {
       array.push(defaultValue);
     } else {
-      const copy = deepCopy(defaultValue) as T;
+      const copy = deepCopy(defaultValue);
       array.push(copy);
     }
   });

package/src/functions/kColor.ts

@@ -1,12 +1,18 @@
+import { CopyableIsaacAPIClassType } from "isaac-typescript-definitions";
 import { SerializationBrand } from "../enums/private/SerializationBrand";
 import { isaacAPIClassEquals, isIsaacAPIClassOfType } from "./isaacAPIClass";
 import { getRandom } from "./random";
 import { getRandomSeed, isRNG, newRNG } from "./rng";
-import { copyValuesToTable, getNumbersFromTable, tableHasKeys } from "./table";
+import {
+  copyUserdataValuesToTable,
+  getNumbersFromTable,
+  tableHasKeys,
+} from "./table";
 import { isTable } from "./types";
 
 export type SerializedKColor = LuaMap<string, unknown> & {
   readonly __serializedKColorBrand: symbol;
+  readonly __kind: CopyableIsaacAPIClassType.K_COLOR;
 };
 
 const OBJECT_NAME = "KColor";
@@ -117,7 +123,7 @@ export function serializeKColor(kColor: KColor): SerializedKColor {
   }
 
   const kColorTable = new LuaMap<string, unknown>();
-  copyValuesToTable(kColor, KEYS, kColorTable);
+  copyUserdataValuesToTable(kColor, KEYS, kColorTable);
   kColorTable.set(SerializationBrand.K_COLOR, "");
   return kColorTable as SerializedKColor;
 }

package/src/functions/rng.ts

@@ -1,3 +1,4 @@
+import { CopyableIsaacAPIClassType } from "isaac-typescript-definitions";
 import { game } from "../core/cachedClasses";
 import { SerializationBrand } from "../enums/private/SerializationBrand";
 import { isaacAPIClassEquals, isIsaacAPIClassOfType } from "./isaacAPIClass";
@@ -6,6 +7,7 @@ import { isTable } from "./types";
 
 export type SerializedRNG = LuaMap<string, unknown> & {
   readonly __serializedRNGBrand: symbol;
+  readonly __kind: CopyableIsaacAPIClassType.RNG;
 };
 
 /**

package/src/functions/serialization.ts

@@ -1,7 +1,13 @@
-import { CopyableIsaacAPIClassType } from "../enums/private/CopyableIsaacAPIClassType";
+import { CopyableIsaacAPIClassType } from "isaac-typescript-definitions";
 import { ISAAC_API_CLASS_TYPE_TO_BRAND } from "../objects/isaacAPIClassTypeToBrand";
-import { ISAAC_API_CLASS_TYPE_TO_FUNCTIONS } from "../objects/isaacAPIClassTypeToFunctions";
-import { SerializedIsaacAPIClass } from "../types/SerializedIsaacAPIClass";
+import {
+  CopyableIsaacAPIClass,
+  IsaacAPIClassTypeFunctions,
+  IsaacAPIClassTypeToSerializedType,
+  IsaacAPIClassTypeToType,
+  ISAAC_API_CLASS_TYPE_TO_FUNCTIONS,
+  SerializedIsaacAPIClass,
+} from "../objects/isaacAPIClassTypeToFunctions";
 import { getIsaacAPIClassName } from "./isaacAPIClass";
 import { isTable, isUserdata } from "./types";
 
@@ -11,7 +17,9 @@ import { isTable, isUserdata } from "./types";
  *
  * For the list of supported classes, see the `CopyableIsaacAPIClassType` enum.
  */
-export function copyIsaacAPIClass(isaacAPIClass: unknown): unknown {
+export function copyIsaacAPIClass<T extends CopyableIsaacAPIClass>(
+  isaacAPIClass: T,
+): T {
   if (!isUserdata(isaacAPIClass)) {
     error(
       `Failed to copy an Isaac API class since the provided object was of type: ${typeof isaacAPIClass}`,
@@ -27,9 +35,19 @@ export function copyIsaacAPIClass(isaacAPIClass: unknown): unknown {
 
   const copyableIsaacAPIClassType =
     isaacAPIClassType as CopyableIsaacAPIClassType;
-  const functions =
-    ISAAC_API_CLASS_TYPE_TO_FUNCTIONS[copyableIsaacAPIClassType];
-  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+
+  type ThisIsaacAPIClassType = T;
+  type ThisSerializedIsaacAPIClassType =
+    IsaacAPIClassTypeToSerializedType[T["__kind"]];
+
+  const functions = ISAAC_API_CLASS_TYPE_TO_FUNCTIONS[
+    copyableIsaacAPIClassType
+  ] as unknown as
+    | IsaacAPIClassTypeFunctions<
+        ThisIsaacAPIClassType,
+        ThisSerializedIsaacAPIClassType
+      >
+    | undefined;
   if (functions === undefined) {
     error(
       `Failed to copy an Isaac API class since the associated functions were not found for Isaac API class type: ${copyableIsaacAPIClassType}`,
@@ -46,9 +64,11 @@ export function copyIsaacAPIClass(isaacAPIClass: unknown): unknown {
  *
  * For the list of supported classes, see the `CopyableIsaacAPIClassType` enum.
  */
-export function deserializeIsaacAPIClass(
-  serializedIsaacAPIClass: unknown,
-): unknown {
+export function deserializeIsaacAPIClass<
+  SerializedT extends SerializedIsaacAPIClass,
+>(
+  serializedIsaacAPIClass: SerializedT,
+): IsaacAPIClassTypeToType[SerializedT["__kind"]] {
   if (!isTable(serializedIsaacAPIClass)) {
     error(
       `Failed to deserialize an Isaac API class since the provided object was of type: ${typeof serializedIsaacAPIClass}`,
@@ -64,9 +84,17 @@ export function deserializeIsaacAPIClass(
     );
   }
 
-  const functions =
-    ISAAC_API_CLASS_TYPE_TO_FUNCTIONS[copyableIsaacAPIClassType];
-  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+  type ThisIsaacAPIClassType = IsaacAPIClassTypeToType[SerializedT["__kind"]];
+  type ThisSerializedIsaacAPIClassType = SerializedT;
+
+  const functions = ISAAC_API_CLASS_TYPE_TO_FUNCTIONS[
+    copyableIsaacAPIClassType
+  ] as unknown as
+    | IsaacAPIClassTypeFunctions<
+        ThisIsaacAPIClassType,
+        ThisSerializedIsaacAPIClassType
+      >
+    | undefined;
   if (functions === undefined) {
     error(
       `Failed to deserialize an Isaac API class since the associated functions were not found for class type: ${copyableIsaacAPIClassType}`,
@@ -81,7 +109,7 @@ export function deserializeIsaacAPIClass(
  * serialized table for brands.
  */
 function getSerializedTableType(
-  serializedIsaacAPIClass: LuaMap<AnyNotNil, unknown>,
+  serializedIsaacAPIClass: SerializedIsaacAPIClass,
 ): CopyableIsaacAPIClassType | undefined {
   for (const [copyableIsaacAPIClassType, serializationBrand] of Object.entries(
     ISAAC_API_CLASS_TYPE_TO_BRAND,
@@ -94,6 +122,20 @@ function getSerializedTableType(
   return undefined;
 }
 
+/**
+ * Helper function to generically check if a given object is a copyable Isaac API class. (This is
+ * used by the save data manager when determining what is safe to copy.)
+ *
+ * For the list of supported classes, see the `CopyableIsaacAPIClassType` enum.
+ */
+export function isCopyableIsaacAPIClass(
+  object: unknown,
+): object is CopyableIsaacAPIClass {
+  const allFunctions = Object.values(ISAAC_API_CLASS_TYPE_TO_FUNCTIONS);
+  const isFunctions = allFunctions.map((functions) => functions.is);
+  return isFunctions.some((identityFunction) => identityFunction(object));
+}
+
 /**
  * Helper function to generically check if a given Lua table is a serialized Isaac API class. (This
  * is used by the save data manager when reading data from the "save#.dat" file.)
@@ -118,7 +160,9 @@ export function isSerializedIsaacAPIClass(
  *
  * For the list of supported classes, see the `CopyableIsaacAPIClassType` enum.
  */
-export function serializeIsaacAPIClass(isaacAPIClass: unknown): unknown {
+export function serializeIsaacAPIClass<T extends CopyableIsaacAPIClass>(
+  isaacAPIClass: T,
+): IsaacAPIClassTypeToSerializedType[T["__kind"]] {
   if (!isUserdata(isaacAPIClass)) {
     error(
       `Failed to serialize an Isaac API class since the provided object was of type: ${typeof isaacAPIClass}`,
@@ -134,9 +178,19 @@ export function serializeIsaacAPIClass(isaacAPIClass: unknown): unknown {
 
   const copyableIsaacAPIClassType =
     isaacAPIClassType as CopyableIsaacAPIClassType;
-  const functions =
-    ISAAC_API_CLASS_TYPE_TO_FUNCTIONS[copyableIsaacAPIClassType];
-  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+
+  type ThisIsaacAPIClassType = T;
+  type ThisSerializedIsaacAPIClassType =
+    IsaacAPIClassTypeToSerializedType[T["__kind"]];
+
+  const functions = ISAAC_API_CLASS_TYPE_TO_FUNCTIONS[
+    copyableIsaacAPIClassType
+  ] as unknown as
+    | IsaacAPIClassTypeFunctions<
+        ThisIsaacAPIClassType,
+        ThisSerializedIsaacAPIClassType
+      >
+    | undefined;
   if (functions === undefined) {
     error(
       `Failed to serialize an Isaac API class since the associated functions were not found for class type: ${copyableIsaacAPIClassType}`,