@etothepii/satisfactory-file-parser 0.0.31 → 0.0.32

package/build/parser/parser.js

@@ -4,18 +4,37 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "./satisfactory/blueprint/blueprint-reader", "./satisfactory/blueprint/blueprint-writer", "./satisfactory/save/level.class", "./satisfactory/save/satisfactory-save", "./satisfactory/save/save-reader", "./satisfactory/save/save-writer"], factory);
+        define(["require", "exports", "stream/web", "./satisfactory/blueprint/blueprint-reader", "./satisfactory/blueprint/blueprint-writer", "./satisfactory/save/level.class", "./satisfactory/save/satisfactory-save", "./satisfactory/save/save-reader", "./satisfactory/save/save-writer", "./stream/save-stream-reader.class", "./stream/save-stream-writer.class"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.Parser = void 0;
+    exports.Parser = exports.PassthroughWebTransform = void 0;
+    const web_1 = require("stream/web");
     const blueprint_reader_1 = require("./satisfactory/blueprint/blueprint-reader");
     const blueprint_writer_1 = require("./satisfactory/blueprint/blueprint-writer");
     const level_class_1 = require("./satisfactory/save/level.class");
     const satisfactory_save_1 = require("./satisfactory/save/satisfactory-save");
     const save_reader_1 = require("./satisfactory/save/save-reader");
     const save_writer_1 = require("./satisfactory/save/save-writer");
+    const save_stream_reader_class_1 = require("./stream/save-stream-reader.class");
+    const save_stream_writer_class_1 = require("./stream/save-stream-writer.class");
+    class PassthroughWebTransform extends web_1.TransformStream {
+        constructor() {
+            super({
+                start: (controller) => {
+                },
+                transform: async (chunk, controller) => {
+                    chunk = await chunk;
+                    controller.enqueue(chunk);
+                },
+                flush: (controller) => {
+                    console.log('on passthrough dispose.');
+                }
+            });
+        }
+    }
+    exports.PassthroughWebTransform = PassthroughWebTransform;
     class Parser {
         static WriteSave(save, onBinaryBeforeCompressing, onHeader, onChunk) {
             const writer = new save_writer_1.SaveWriter();
@@ -26,6 +45,68 @@
             const chunkSummary = writer.generateChunks(save.compressionInfo, posAfterHeader, onBinaryBeforeCompressing, onHeader, onChunk);
             return chunkSummary;
         }
+        static async ParseSaveFileStream(input, output, binaryOutput) {
+            return new Promise(async (resolve, reject) => {
+                if (input.locked || output.locked || (binaryOutput !== undefined ? binaryOutput.locked : false)) {
+                    throw new Error('One of the input/output streams is locked. Aborting save parsing.');
+                }
+                const binaryOutWriter = binaryOutput ? binaryOutput.getWriter() : undefined;
+                const writer = new save_stream_writer_class_1.SaveStreamWriter(output.getWriter());
+                const reader = new save_stream_reader_class_1.SaveStreamReader(input.getReader(), 500 * 1000 * 1000);
+                const passthrough = new PassthroughWebTransform();
+                const passthroughWriter = passthrough.writable.getWriter();
+                const passthroughReader = new save_stream_reader_class_1.SaveStreamReader(passthrough.readable.getReader(), 3000 * 1000 * 1000);
+                await writer.beginSave();
+                const header = await reader.readHeader();
+                await writer.writeHeader(header);
+                let contentParsingPromise;
+                const decompressionPromise = Parser.DecompressStreamSave(reader, writer, passthroughWriter, async () => {
+                    console.log('start streaming content');
+                    passthroughReader.debug = true;
+                    contentParsingPromise = await Parser.ParseStreamSave(passthroughReader, writer, header);
+                    await writer.close();
+                    return resolve();
+                }, binaryOutWriter);
+            });
+        }
+        static async ParseStreamSave(reader, jsonWriter, header) {
+            return new Promise(async (resolve, reject) => {
+                reader.onCloseCallback = async () => {
+                    console.log('content reader closes.');
+                    await jsonWriter.endLevels();
+                    await jsonWriter.endSave();
+                    return resolve();
+                };
+                console.log('before open levels');
+                await jsonWriter.openLevels();
+                const dataLength = await reader.readInt32();
+                await reader.allocate(Math.min(1000, dataLength));
+                console.log(`incoming body size should be ${dataLength} bytes big.`);
+                await reader.streamLevelsToOutput(jsonWriter, header);
+                await reader.close();
+            });
+        }
+        static async DecompressStreamSave(reader, jsonWriter, outputWriter, onDecompressionInfoWritten, debugAdditionalBinaryOutputWriter) {
+            return new Promise(async (resolve, reject) => {
+                reader.onCloseCallback = async () => {
+                    console.log('decompress reader closes.');
+                    return resolve();
+                };
+                let first = true;
+                while (reader.hasInput()) {
+                    const decompressedChunk = await reader.readBodyChunk();
+                    if (first && reader.compressionInfo) {
+                        await jsonWriter.writeCompressionInfo(reader.compressionInfo);
+                        onDecompressionInfoWritten();
+                        first = false;
+                    }
+                    if (debugAdditionalBinaryOutputWriter) {
+                        debugAdditionalBinaryOutputWriter.write(decompressedChunk);
+                    }
+                    outputWriter.write(decompressedChunk);
+                }
+            });
+        }
         static ParseSaveFile(file, onDecompressedSaveBody = () => { }, onProgress = () => { }) {
             const reader = new save_reader_1.SaveReader(new Uint8Array(file).buffer, onProgress);
             const header = reader.readHeader();
@@ -38,6 +119,23 @@
             save.trailingCollectedObjects = reader.trailingCollectedObjects;
             return save;
         }
+        static async ParseSaveFileAsynchronousToOutput(file, outputJson, onDecompressedSaveBody = () => { }, onProgress = () => { }) {
+            const reader = new save_reader_1.SaveReader(new Uint8Array(file).buffer, onProgress);
+            const writer = new save_stream_writer_class_1.SaveStreamWriter(outputJson.getWriter());
+            await writer.beginSave();
+            const header = reader.readHeader();
+            const save = new satisfactory_save_1.SatisfactorySave(header);
+            await writer.writeHeader(save.header);
+            await writer.writeCompressionInfo({});
+            const inflateResult = reader.inflateChunks();
+            onDecompressedSaveBody(reader.getBuffer());
+            const levelParseResult = await reader.readLevelsAsynchronously(writer);
+            save.levels = reader.levels;
+            save.compressionInfo = reader.compressionInfo;
+            save.trailingCollectedObjects = reader.trailingCollectedObjects;
+            await writer.endSave();
+            return save;
+        }
         static WriteBlueprintFiles(blueprint, onMainFileBinaryBeforeCompressing = () => { }, onMainFileHeader = () => { }, onMainFileChunk = () => { }) {
             const blueprintWriter = new blueprint_writer_1.BlueprintWriter();
             blueprint_writer_1.BlueprintWriter.SerializeHeader(blueprintWriter, blueprint.header);

package/build/parser/satisfactory/blueprint/blueprint-reader.d.ts

@@ -1,3 +1,4 @@
+import { BinaryReadable } from "../../byte/binary-readable.interface";
 import { ByteReader } from "../../byte/byte-reader.class";
 import { ChunkCompressionInfo } from "../../file.types";
 import { SaveComponent } from "../objects/SaveComponent";
@@ -6,7 +7,7 @@ import { BlueprintConfig, BlueprintHeader } from "./blueprint.types";
 export declare class BlueprintReader extends ByteReader {
     compressionInfo: ChunkCompressionInfo;
     constructor(bluePrintBuffer: ArrayBuffer);
-    static ReadHeader(reader: ByteReader): BlueprintHeader;
+    static ReadHeader(reader: BinaryReadable): BlueprintHeader;
     inflateChunks(): any;
     static ParseObjects(reader: ByteReader): (SaveEntity | SaveComponent)[];
 }
@@ -14,5 +15,5 @@ export declare class BlueprintConfigReader extends ByteReader {
     bluePrintConfigBuffer: ArrayBuffer;
     constructor(bluePrintConfigBuffer: ArrayBuffer);
     parse: () => BlueprintConfig;
-    static ParseConfig(reader: ByteReader): BlueprintConfig;
+    static ParseConfig(reader: BinaryReadable): BlueprintConfig;
 }

package/build/parser/satisfactory/blueprint/blueprint-writer.js

@@ -54,7 +54,7 @@
             writer.writeInt32(0);
             level_class_1.Level.SerializeObjectHeaders(writer, objects);
             writer.writeBinarySizeFromPosition(headersLenIndicator, headersLenIndicator + 4);
-            level_class_1.Level.SerializeObjectContents(writer, objects, 0);
+            level_class_1.Level.SerializeObjectContents(writer, objects, 0, '');
         }
     }
     exports.BlueprintWriter = BlueprintWriter;

package/build/parser/satisfactory/objects/DataFields.d.ts

@@ -1,13 +1,41 @@
-import { ByteReader } from "../../byte/byte-reader.class";
+import { ByteWriter } from "../../..";
+import { BinaryReadable } from "../../byte/binary-readable.interface";
 import { SaveWriter } from "../save/save-writer";
+import { vec3 } from "../structs/util.types";
+import { ObjectReference } from "./ObjectReference";
 import { AbstractBaseProperty } from "./Property";
+export type SpecialAnyProperty = {} | PowerLineSpecialProperty;
+export type PowerLineSpecialProperty = {
+    num: number;
+    source: ObjectReference;
+    target: ObjectReference;
+    sourceTranslation?: vec3;
+    targetTranslation?: vec3;
+};
+export type PlayerSpecialProperty = {
+    flag: number;
+    eosData?: string;
+    steamPlayerData?: string;
+};
+export type ItemSpecialProperty = {
+    length: number;
+    name: string;
+    position: number;
+    pathName: string;
+};
+export type ConveyorSpecialProperty = {
+    items: ItemSpecialProperty[];
+};
 export declare class DataFields {
-    properties: any[];
+    properties: AbstractBaseProperty[];
+    specialProperties: SpecialAnyProperty;
     trailingData: number[];
     shouldBeNulled: boolean;
     constructor();
-    static Parse(length: number, reader: ByteReader, buildVersion: number): DataFields;
-    static ParseProperty(reader: ByteReader, buildVersion: number, propertyName: string): AbstractBaseProperty | null;
-    static Serialize(writer: SaveWriter, fields: DataFields, buildVersion: number): void;
-    static SerializeProperty(writer: SaveWriter, property: AbstractBaseProperty, propertyName: string, buildVersion: number): void;
+    static Parse(length: number, reader: BinaryReadable, buildVersion: number, typePath: string): DataFields;
+    static ParseAdditionalSpecialProperties(reader: BinaryReadable, typePath: string, remainingLen: number): SpecialAnyProperty;
+    static ParseProperty(reader: BinaryReadable, buildVersion: number, propertyName: string): AbstractBaseProperty | null;
+    static Serialize(writer: SaveWriter, fields: DataFields, buildVersion: number, typePath: string): void;
+    static SerializeAdditionalSpecialProperties(writer: ByteWriter, typePath: string, property: SpecialAnyProperty): void;
+    static SerializeProperty(writer: ByteWriter, property: AbstractBaseProperty, propertyName: string, buildVersion: number): void;
 }

package/build/parser/satisfactory/objects/DataFields.js

@@ -4,20 +4,22 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "./Property"], factory);
+        define(["require", "exports", "../structs/util.types", "./Property"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.DataFields = void 0;
+    const util_types_1 = require("../structs/util.types");
     const Property_1 = require("./Property");
     class DataFields {
         constructor() {
             this.properties = [];
+            this.specialProperties = {};
             this.trailingData = [];
             this.shouldBeNulled = false;
         }
-        static Parse(length, reader, buildVersion) {
+        static Parse(length, reader, buildVersion, typePath) {
             const start = reader.getBufferPosition();
             const fields = new DataFields();
             if (length === 0) {
@@ -33,11 +35,58 @@
             let int1 = reader.readInt32();
             if (int1 !== 0) {
             }
+            fields.specialProperties = DataFields.ParseAdditionalSpecialProperties(reader, typePath, start + length - reader.getBufferPosition() - 4);
             const end = reader.getBufferPosition();
             let remainingBytes = start + length - end;
             fields.trailingData = Array.from(reader.readBytes(remainingBytes));
             return fields;
         }
+        static ParseAdditionalSpecialProperties(reader, typePath, remainingLen) {
+            let property;
+            switch (typePath) {
+                case '/Game/FactoryGame/Buildable/Factory/ConveyorBeltMk1/Build_ConveyorBeltMk1.Build_ConveyorBeltMk1_C':
+                case '/Game/FactoryGame/Buildable/Factory/ConveyorBeltMk2/Build_ConveyorBeltMk2.Build_ConveyorBeltMk2_C':
+                case '/Game/FactoryGame/Buildable/Factory/ConveyorBeltMk3/Build_ConveyorBeltMk3.Build_ConveyorBeltMk3_C':
+                case '/Game/FactoryGame/Buildable/Factory/ConveyorBeltMk4/Build_ConveyorBeltMk4.Build_ConveyorBeltMk4_C':
+                case '/Game/FactoryGame/Buildable/Factory/ConveyorBeltMk5/Build_ConveyorBeltMk5.Build_ConveyorBeltMk5_C':
+                case '/Game/FactoryGame/Buildable/Factory/ConveyorLiftMk1/Build_ConveyorLiftMk1.Build_ConveyorLiftMk1_C':
+                case '/Game/FactoryGame/Buildable/Factory/ConveyorLiftMk2/Build_ConveyorLiftMk2.Build_ConveyorLiftMk2_C':
+                case '/Game/FactoryGame/Buildable/Factory/ConveyorLiftMk3/Build_ConveyorLiftMk3.Build_ConveyorLiftMk3_C':
+                case '/Game/FactoryGame/Buildable/Factory/ConveyorLiftMk4/Build_ConveyorLiftMk4.Build_ConveyorLiftMk4_C':
+                case '/Game/FactoryGame/Buildable/Factory/ConveyorLiftMk5/Build_ConveyorLiftMk5.Build_ConveyorLiftMk5_C':
+                    property = {};
+                    break;
+                case '/Game/FactoryGame/Buildable/Factory/PowerLine/Build_PowerLine.Build_PowerLine_C':
+                case '/Game/FactoryGame/Events/Christmas/Buildings/PowerLineLights/Build_XmassLightsLine.Build_XmassLightsLine_C':
+                    property = {
+                        source: Property_1.ObjectProperty.ReadValue(reader),
+                        target: Property_1.ObjectProperty.ReadValue(reader)
+                    };
+                    if (remainingLen >= 24) {
+                        property.sourceTranslation = (0, util_types_1.ParseVec3)(reader);
+                        property.targetTranslation = (0, util_types_1.ParseVec3)(reader);
+                    }
+                    break;
+                case '/Game/FactoryGame/Character/Player/BP_PlayerState.BP_PlayerState_C':
+                    property = {};
+                    property.flag = reader.readByte();
+                    switch (property.flag) {
+                        case 248:
+                            const eos = reader.readString();
+                            property.eosData = reader.readString();
+                            break;
+                        case 25:
+                            break;
+                        default:
+                            break;
+                    }
+                    break;
+                default:
+                    property = {};
+                    break;
+            }
+            return property;
+        }
         static ParseProperty(reader, buildVersion, propertyName) {
             let currentProperty = {};
             if (currentProperty.name === 'None') {
@@ -131,15 +180,49 @@
             }
             return currentProperty;
         }
-        static Serialize(writer, fields, buildVersion) {
+        static Serialize(writer, fields, buildVersion, typePath) {
             for (const property of fields.properties) {
                 writer.writeString(property.name);
                 DataFields.SerializeProperty(writer, property, property.name, buildVersion);
             }
             writer.writeString('None');
             writer.writeInt32(0);
+            DataFields.SerializeAdditionalSpecialProperties(writer, typePath, fields.specialProperties);
             writer.writeBytesArray(fields.trailingData);
         }
+        static SerializeAdditionalSpecialProperties(writer, typePath, property) {
+            switch (typePath) {
+                case '/Game/FactoryGame/Buildable/Factory/ConveyorBeltMk1/Build_ConveyorBeltMk1.Build_ConveyorBeltMk1_C':
+                case '/Game/FactoryGame/Buildable/Factory/ConveyorBeltMk2/Build_ConveyorBeltMk2.Build_ConveyorBeltMk2_C':
+                case '/Game/FactoryGame/Buildable/Factory/ConveyorBeltMk3/Build_ConveyorBeltMk3.Build_ConveyorBeltMk3_C':
+                case '/Game/FactoryGame/Buildable/Factory/ConveyorBeltMk4/Build_ConveyorBeltMk4.Build_ConveyorBeltMk4_C':
+                case '/Game/FactoryGame/Buildable/Factory/ConveyorBeltMk5/Build_ConveyorBeltMk5.Build_ConveyorBeltMk5_C':
+                case '/Game/FactoryGame/Buildable/Factory/ConveyorLiftMk1/Build_ConveyorLiftMk1.Build_ConveyorLiftMk1_C':
+                case '/Game/FactoryGame/Buildable/Factory/ConveyorLiftMk2/Build_ConveyorLiftMk2.Build_ConveyorLiftMk2_C':
+                case '/Game/FactoryGame/Buildable/Factory/ConveyorLiftMk3/Build_ConveyorLiftMk3.Build_ConveyorLiftMk3_C':
+                case '/Game/FactoryGame/Buildable/Factory/ConveyorLiftMk4/Build_ConveyorLiftMk4.Build_ConveyorLiftMk4_C':
+                case '/Game/FactoryGame/Buildable/Factory/ConveyorLiftMk5/Build_ConveyorLiftMk5.Build_ConveyorLiftMk5_C':
+                    break;
+                case '/Game/FactoryGame/Buildable/Factory/PowerLine/Build_PowerLine.Build_PowerLine_C':
+                case '/Game/FactoryGame/Events/Christmas/Buildings/PowerLineLights/Build_XmassLightsLine.Build_XmassLightsLine_C':
+                    Property_1.ObjectProperty.SerializeValue(writer, property.source);
+                    Property_1.ObjectProperty.SerializeValue(writer, property.target);
+                    break;
+                case '/Game/FactoryGame/Character/Player/BP_PlayerState.BP_PlayerState_C':
+                    writer.writeByte(property.flag);
+                    switch (property.flag) {
+                        case 248:
+                            writer.writeString('EOS');
+                            writer.writeString(property.eosData);
+                            break;
+                        case 25:
+                            break;
+                        default:
+                            break;
+                    }
+                    break;
+            }
+        }
         static SerializeProperty(writer, property, propertyName, buildVersion) {
             writer.writeString(property.ueType);
             const lenIndicator = writer.getBufferPosition();

package/build/parser/satisfactory/objects/ObjectReference.d.ts

@@ -1,9 +1,9 @@
-import { ByteReader } from "../../byte/byte-reader.class";
+import { BinaryReadable } from "../../byte/binary-readable.interface";
 import { ByteWriter } from "../../byte/byte-writer.class";
 export declare class ObjectReference {
     levelName: string;
     pathName: string;
     constructor(levelName: string, pathName: string);
-    static Parse(reader: ByteReader): ObjectReference;
+    static Parse(reader: BinaryReadable): ObjectReference;
     static Serialize(writer: ByteWriter, ref: ObjectReference): void;
 }

package/build/parser/satisfactory/objects/Property.d.ts

@@ -1,5 +1,5 @@
-import { ByteReader } from "../../byte/byte-reader.class";
-import { SaveWriter } from "../save/save-writer";
+import { ByteWriter } from "../../..";
+import { BinaryReadable } from "../../byte/binary-readable.interface";
 import { col4, vec3, vec4 } from "../structs/util.types";
 import { ObjectReference } from "./ObjectReference";
 export type Properties = {
@@ -20,19 +20,19 @@ export declare abstract class BasicProperty extends AbstractBaseProperty {
     constructor(type: string, ueType: string, guidInfo: GUID, index?: number);
 }
 export type GUID = undefined | Uint8Array;
-export declare const ParseGUID: (reader: ByteReader) => GUID;
-export declare const SerializeGUID: (writer: SaveWriter, guid: GUID) => void;
+export declare const ParseGUID: (reader: BinaryReadable) => GUID;
+export declare const SerializeGUID: (writer: ByteWriter, guid: GUID) => void;
 export type OverheadResult = {
     overhead: number;
 };
 export declare class BoolProperty extends BasicProperty {
     value: boolean;
     constructor(value: boolean, ueType?: string, guidInfo?: GUID, index?: number);
-    static Parse(reader: ByteReader, ueType: string, index?: number): BoolProperty;
-    static ReadValue(reader: ByteReader): boolean;
+    static Parse(reader: BinaryReadable, ueType: string, index?: number): BoolProperty;
+    static ReadValue(reader: BinaryReadable): boolean;
     static CalcOverhead(property: BoolProperty): number;
-    static Serialize(writer: SaveWriter, property: BoolProperty): void;
-    static SerializeValue(writer: SaveWriter, value: boolean): void;
+    static Serialize(writer: ByteWriter, property: BoolProperty): void;
+    static SerializeValue(writer: ByteWriter, value: boolean): void;
 }
 export type BytePropertyValue = {
     type: string;
@@ -41,92 +41,92 @@ export type BytePropertyValue = {
 export declare class ByteProperty extends BasicProperty {
     value: BytePropertyValue;
     constructor(value: BytePropertyValue, ueType?: string, guidInfo?: GUID, index?: number);
-    static Parse(reader: ByteReader, ueType: string, index?: number): ByteProperty;
-    static ReadValue(reader: ByteReader): number;
+    static Parse(reader: BinaryReadable, ueType: string, index?: number): ByteProperty;
+    static ReadValue(reader: BinaryReadable): number;
     static CalcOverhead(property: ByteProperty): number;
-    static Serialize(writer: SaveWriter, property: ByteProperty): void;
-    static SerializeValue(writer: SaveWriter, value: number): void;
+    static Serialize(writer: ByteWriter, property: ByteProperty): void;
+    static SerializeValue(writer: ByteWriter, value: number): void;
 }
 export declare class Int8Property extends BasicProperty {
     value: number;
     constructor(value: number, ueType?: string, guidInfo?: GUID, index?: number);
-    static Parse(reader: ByteReader, ueType: string, index?: number): Int8Property;
-    static ReadValue(reader: ByteReader): number;
+    static Parse(reader: BinaryReadable, ueType: string, index?: number): Int8Property;
+    static ReadValue(reader: BinaryReadable): number;
     static CalcOverhead(property: Int8Property): number;
-    static Serialize(writer: SaveWriter, property: Int8Property): void;
-    static SerializeValue(writer: SaveWriter, value: number): void;
+    static Serialize(writer: ByteWriter, property: Int8Property): void;
+    static SerializeValue(writer: ByteWriter, value: number): void;
 }
 export declare class Uint8Property extends BasicProperty {
     value: number;
     constructor(value: number, ueType?: string, guidInfo?: GUID, index?: number);
-    static Parse(reader: ByteReader, ueType: string, index?: number): Uint8Property;
-    static ReadValue(reader: ByteReader): number;
+    static Parse(reader: BinaryReadable, ueType: string, index?: number): Uint8Property;
+    static ReadValue(reader: BinaryReadable): number;
     static CalcOverhead(property: Uint8Property): number;
-    static Serialize(writer: SaveWriter, property: Uint8Property): void;
-    static SerializeValue(writer: SaveWriter, value: number): void;
+    static Serialize(writer: ByteWriter, property: Uint8Property): void;
+    static SerializeValue(writer: ByteWriter, value: number): void;
 }
 export declare class Int32Property extends BasicProperty {
     value: number;
     constructor(value: number, ueType?: string, guidInfo?: GUID, index?: number);
-    static Parse(reader: ByteReader, ueType: string, index?: number): Int32Property;
-    static ReadValue(reader: ByteReader): number;
+    static Parse(reader: BinaryReadable, ueType: string, index?: number): Int32Property;
+    static ReadValue(reader: BinaryReadable): number;
     static CalcOverhead(property: Int32Property): number;
-    static Serialize(writer: SaveWriter, property: Int32Property): void;
-    static SerializeValue(writer: SaveWriter, value: number): void;
+    static Serialize(writer: ByteWriter, property: Int32Property): void;
+    static SerializeValue(writer: ByteWriter, value: number): void;
 }
 export declare class Uint32Property extends BasicProperty {
     value: number;
     constructor(value: number, ueType?: string, guidInfo?: GUID, index?: number);
-    static Parse(reader: ByteReader, ueType: string, index?: number): Uint32Property;
-    static ReadValue(reader: ByteReader): number;
+    static Parse(reader: BinaryReadable, ueType: string, index?: number): Uint32Property;
+    static ReadValue(reader: BinaryReadable): number;
     static CalcOverhead(property: Uint32Property): number;
-    static Serialize(writer: SaveWriter, property: Uint32Property): void;
-    static SerializeValue(writer: SaveWriter, value: number): void;
+    static Serialize(writer: ByteWriter, property: Uint32Property): void;
+    static SerializeValue(writer: ByteWriter, value: number): void;
 }
 export declare class Int64Property extends BasicProperty {
     value: string;
     constructor(value: string, ueType?: string, guidInfo?: GUID, index?: number);
-    static Parse(reader: ByteReader, ueType: string, index?: number): Int64Property;
-    static ReadValue(reader: ByteReader): string;
+    static Parse(reader: BinaryReadable, ueType: string, index?: number): Int64Property;
+    static ReadValue(reader: BinaryReadable): string;
     static CalcOverhead(property: Int64Property): number;
-    static Serialize(writer: SaveWriter, property: Int64Property): void;
-    static SerializeValue(writer: SaveWriter, value: string): void;
+    static Serialize(writer: ByteWriter, property: Int64Property): void;
+    static SerializeValue(writer: ByteWriter, value: string): void;
 }
 export declare class FloatProperty extends BasicProperty {
     value: number;
     constructor(value: number, ueType?: string, guidInfo?: GUID, index?: number);
-    static Parse(reader: ByteReader, ueType: string, index?: number): FloatProperty;
+    static Parse(reader: BinaryReadable, ueType: string, index?: number): FloatProperty;
     static CalcOverhead(property: FloatProperty): number;
-    static ReadValue(reader: ByteReader): number;
-    static Serialize(writer: SaveWriter, property: FloatProperty): void;
-    static SerializeValue(writer: SaveWriter, value: number): void;
+    static ReadValue(reader: BinaryReadable): number;
+    static Serialize(writer: ByteWriter, property: FloatProperty): void;
+    static SerializeValue(writer: ByteWriter, value: number): void;
 }
 export declare class DoubleProperty extends BasicProperty {
     value: number;
     constructor(value: number, ueType?: string, guidInfo?: GUID, index?: number);
-    static Parse(reader: ByteReader, ueType: string, index?: number): DoubleProperty;
-    static ReadValue(reader: ByteReader): number;
+    static Parse(reader: BinaryReadable, ueType: string, index?: number): DoubleProperty;
+    static ReadValue(reader: BinaryReadable): number;
     static CalcOverhead(property: DoubleProperty): number;
-    static Serialize(writer: SaveWriter, property: DoubleProperty): void;
-    static SerializeValue(writer: SaveWriter, value: number): void;
+    static Serialize(writer: ByteWriter, property: DoubleProperty): void;
+    static SerializeValue(writer: ByteWriter, value: number): void;
 }
 export declare class StrProperty extends BasicProperty {
     value: string;
     constructor(value: string, ueType?: string, guidInfo?: GUID, index?: number);
-    static Parse(reader: ByteReader, ueType: string, index?: number): StrProperty;
-    static ReadValue(reader: ByteReader): string;
+    static Parse(reader: BinaryReadable, ueType: string, index?: number): StrProperty;
+    static ReadValue(reader: BinaryReadable): string;
     static CalcOverhead(property: StrProperty): number;
-    static Serialize(writer: SaveWriter, property: StrProperty): void;
-    static SerializeValue(writer: SaveWriter, value: string): void;
+    static Serialize(writer: ByteWriter, property: StrProperty): void;
+    static SerializeValue(writer: ByteWriter, value: string): void;
 }
 export declare class ObjectProperty extends BasicProperty {
     value: ObjectReference;
     constructor(value: ObjectReference, ueType?: string, guidInfo?: GUID, index?: number);
-    static Parse(reader: ByteReader, ueType: string, index?: number): ObjectProperty;
-    static ReadValue(reader: ByteReader): ObjectReference;
+    static Parse(reader: BinaryReadable, ueType: string, index?: number): ObjectProperty;
+    static ReadValue(reader: BinaryReadable): ObjectReference;
     static CalcOverhead(property: ObjectProperty): number;
-    static Serialize(writer: SaveWriter, property: ObjectProperty): void;
-    static SerializeValue(writer: SaveWriter, value: {
+    static Serialize(writer: ByteWriter, property: ObjectProperty): void;
+    static SerializeValue(writer: ByteWriter, value: {
         levelName: string;
         pathName: string;
     }): void;
@@ -140,11 +140,11 @@ export declare class EnumProperty extends BasicProperty {
         name: string;
         value: string;
     }, ueType?: string, guidInfo?: GUID, index?: number);
-    static Parse(reader: ByteReader, ueType: string, index?: number): EnumProperty;
-    static ReadValue(reader: ByteReader): string;
+    static Parse(reader: BinaryReadable, ueType: string, index?: number): EnumProperty;
+    static ReadValue(reader: BinaryReadable): string;
     static CalcOverhead(property: EnumProperty): number;
-    static Serialize(writer: SaveWriter, property: EnumProperty): void;
-    static SerializeValue(writer: SaveWriter, value: string): void;
+    static Serialize(writer: ByteWriter, property: EnumProperty): void;
+    static SerializeValue(writer: ByteWriter, value: string): void;
 }
 export type TextPropertyValue = {
     flags: number;
@@ -165,11 +165,11 @@ export type TextPropertyValue = {
 export declare class TextProperty extends BasicProperty {
     value: TextPropertyValue;
     constructor(value: TextPropertyValue, ueType?: string, guidInfo?: GUID, index?: number);
-    static Parse(reader: ByteReader, ueType: string, index?: number): TextProperty;
-    static ParseValue(reader: ByteReader): TextPropertyValue;
+    static Parse(reader: BinaryReadable, ueType: string, index?: number): TextProperty;
+    static ParseValue(reader: BinaryReadable): TextPropertyValue;
     static CalcOverhead(property: TextProperty): number;
-    static Serialize(writer: SaveWriter, property: TextProperty): void;
-    static SerializeValue(writer: SaveWriter, value: TextPropertyValue): void;
+    static Serialize(writer: ByteWriter, property: TextProperty): void;
+    static SerializeValue(writer: ByteWriter, value: TextPropertyValue): void;
 }
 export type BasicMultipleStructPropertyValue = {
     values: any;
@@ -213,11 +213,11 @@ export declare class StructProperty extends AbstractBaseProperty {
     unk3?: number;
     unk4?: number;
     constructor(subtype: string, ueType?: string, index?: number, guid?: number);
-    static Parse(reader: ByteReader, ueType: string, index: number, size: number): StructProperty;
-    static ParseValue(reader: ByteReader, subtype: string, size: number): GENERIC_STRUCT_PROPERTY_VALUE;
+    static Parse(reader: BinaryReadable, ueType: string, index: number, size: number): StructProperty;
+    static ParseValue(reader: BinaryReadable, subtype: string, size: number): GENERIC_STRUCT_PROPERTY_VALUE;
     static CalcOverhead(property: StructProperty): number;
-    static Serialize(writer: SaveWriter, property: StructProperty): void;
-    static SerializeValue(writer: SaveWriter, subtype: string, value: GENERIC_STRUCT_PROPERTY_VALUE): void;
+    static Serialize(writer: ByteWriter, property: StructProperty): void;
+    static SerializeValue(writer: ByteWriter, subtype: string, value: GENERIC_STRUCT_PROPERTY_VALUE): void;
 }
 export type ArrayPropertyStructValueFields = {
     allStructType: string;
@@ -233,17 +233,17 @@ export declare class ArrayProperty<T> extends BasicProperty {
     values: T[];
     structValueFields?: ArrayPropertyStructValueFields | undefined;
     constructor(subtype: string, values: T[], ueType?: string, index?: number, structValueFields?: ArrayPropertyStructValueFields | undefined);
-    static Parse(reader: ByteReader, ueType: string, index: number, propertyName: string): ArrayProperty<any>;
+    static Parse(reader: BinaryReadable, ueType: string, index: number, propertyName: string): ArrayProperty<any>;
     static CalcOverhead(property: ArrayProperty<any>): number;
-    static Serialize(writer: SaveWriter, property: ArrayProperty<any>, propertyName: string): void;
+    static Serialize(writer: ByteWriter, property: ArrayProperty<any>, propertyName: string): void;
 }
 export declare class SetProperty<T> extends BasicProperty {
     subtype: string;
     values: T[];
     constructor(subtype: string, values: T[], ueType: string, index: number);
-    static Parse(reader: ByteReader, ueType: string, index: number, propertyName: string): SetProperty<any>;
+    static Parse(reader: BinaryReadable, ueType: string, index: number, propertyName: string): SetProperty<any>;
     static CalcOverhead(property: SetProperty<any>): number;
-    static Serialize(writer: SaveWriter, property: SetProperty<any>): void;
+    static Serialize(writer: ByteWriter, property: SetProperty<any>): void;
 }
 export declare class MapProperty extends BasicProperty {
     keyType: string;
@@ -258,13 +258,13 @@ export declare class MapProperty extends BasicProperty {
         value: any;
     }[];
     constructor(keyType: string, valueType: string, ueType: string, index: number);
-    static Parse(reader: ByteReader, propertyName: string, buildVersion: number, size: number, ueType?: string, index?: number): MapProperty;
+    static Parse(reader: BinaryReadable, propertyName: string, buildVersion: number, size: number, ueType?: string, index?: number): MapProperty;
     static CalcOverhead(property: MapProperty): number;
-    static Serialize(writer: SaveWriter, property: MapProperty): void;
+    static Serialize(writer: ByteWriter, property: MapProperty): void;
 }
-export declare const ParseDynamicStructData: (reader: ByteReader, buildVersion: number, type: string) => DynamicStructPropertyValue;
-export declare const SerializeDynamicStructData: (writer: SaveWriter, buildVersion: number, data: DynamicStructPropertyValue) => void;
-export declare const ReadFINNetworkTrace: (reader: ByteReader) => any;
-export declare const SerializeFINNetworkTrace: (writer: SaveWriter, obj: any) => void;
-export declare const ReadFINLuaProcessorStateStorage: (reader: ByteReader, size: number) => any;
-export declare const SerializeFINLuaProcessorStateStorage: (writer: SaveWriter, stateStorage: any) => void;
+export declare const ParseDynamicStructData: (reader: BinaryReadable, buildVersion: number, type: string) => DynamicStructPropertyValue;
+export declare const SerializeDynamicStructData: (writer: ByteWriter, buildVersion: number, data: DynamicStructPropertyValue) => void;
+export declare const ReadFINNetworkTrace: (reader: BinaryReadable) => any;
+export declare const SerializeFINNetworkTrace: (writer: ByteWriter, obj: any) => void;
+export declare const ReadFINLuaProcessorStateStorage: (reader: BinaryReadable, size: number) => any;
+export declare const SerializeFINLuaProcessorStateStorage: (writer: ByteWriter, stateStorage: any) => void;