@etothepii/satisfactory-file-parser 0.4.20 → 0.4.22

package/build/parser/satisfactory/types/property/generic/ArrayProperty.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayProperty = exports.isArrayProperty = void 0;
+const SoftObjectReference_1 = require("../../structs/SoftObjectReference");
+const BasicProperty_1 = require("./BasicProperty");
+const BoolProperty_1 = require("./BoolProperty");
+const ByteProperty_1 = require("./ByteProperty");
+const DoubleProperty_1 = require("./DoubleProperty");
+const EnumProperty_1 = require("./EnumProperty");
+const FloatProperty_1 = require("./FloatProperty");
+const Int32Property_1 = require("./Int32Property");
+const Int64Property_1 = require("./Int64Property");
+const ObjectProperty_1 = require("./ObjectProperty");
+const StrProperty_1 = require("./StrProperty");
+const StructProperty_1 = require("./StructProperty");
+const TextProperty_1 = require("./TextProperty");
+const isArrayProperty = (property) => property.type === 'ArrayProperty';
+exports.isArrayProperty = isArrayProperty;
+class ArrayProperty extends BasicProperty_1.BasicProperty {
+    constructor(subtype, values, ueType = 'ArrayProperty', index = 0, structValueFields) {
+        super({ type: 'ArrayProperty', ueType, index });
+        this.subtype = subtype;
+        this.values = values;
+        this.structValueFields = structValueFields;
+    }
+    static Parse(reader, ueType, index, propertyName) {
+        const subtype = reader.readString();
+        reader.skipBytes(1);
+        let property;
+        const elementCount = reader.readInt32();
+        switch (subtype) {
+            case "FloatProperty":
+                property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => FloatProperty_1.FloatProperty.ReadValue(reader)), ueType, index);
+                break;
+            case "BoolProperty":
+                property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => BoolProperty_1.BoolProperty.ReadValue(reader)), ueType, index);
+                break;
+            case "IntProperty":
+                property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => Int32Property_1.Int32Property.ReadValue(reader)), ueType, index);
+                break;
+            case "Int64Property":
+                property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => Int64Property_1.Int64Property.ReadValue(reader)), ueType, index);
+                break;
+            case "DoubleProperty":
+                property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => DoubleProperty_1.DoubleProperty.ReadValue(reader)), ueType, index);
+                break;
+            case "ByteProperty":
+                property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => ByteProperty_1.ByteProperty.ReadValue(reader)), ueType, index);
+                break;
+            case "StrProperty":
+                property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => StrProperty_1.StrProperty.ReadValue(reader)), ueType, index);
+                break;
+            case "EnumProperty":
+                property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => EnumProperty_1.EnumProperty.ReadValue(reader)), ueType, index);
+                break;
+            case "TextProperty":
+                property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => TextProperty_1.TextProperty.ParseValue(reader)), ueType, index);
+                break;
+            case "InterfaceProperty":
+            case "ObjectProperty":
+                property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => ObjectProperty_1.ObjectProperty.ReadValue(reader)), ueType, index);
+                break;
+            case "SoftObjectProperty":
+                property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => SoftObjectReference_1.SoftObjectReference.read(reader)), ueType, index);
+                break;
+            case "StructProperty":
+                const name = reader.readString();
+                const type = reader.readString();
+                const binarySize = reader.readInt32();
+                const allIndex = reader.readInt32();
+                const allStructType = reader.readString();
+                const allGuid = reader.readInt32();
+                const allUnk1 = reader.readInt32();
+                const allUnk2 = reader.readInt32();
+                const allUnk3 = reader.readInt32();
+                const allUnk4 = reader.readByte();
+                const innerStructValueFields = { allStructType, allIndex, allGuid };
+                if (allUnk1 !== 0) {
+                    innerStructValueFields.allUnk1 = allUnk1;
+                }
+                if (allUnk2 !== 0) {
+                    innerStructValueFields.allUnk2 = allUnk2;
+                }
+                if (allUnk3 !== 0) {
+                    innerStructValueFields.allUnk3 = allUnk3;
+                }
+                if (allUnk4 !== 0) {
+                    innerStructValueFields.allUnk4 = allUnk4;
+                }
+                const before = reader.getBufferPosition();
+                const maArr = new Array(elementCount).fill(0).map(() => {
+                    const struct = new StructProperty_1.StructProperty(allStructType, type, allIndex, allGuid);
+                    struct.value = StructProperty_1.StructProperty.ParseValue(reader, allStructType, binarySize);
+                    return struct;
+                });
+                const readBytes = reader.getBufferPosition() - before;
+                if (readBytes !== binarySize) {
+                    throw new Error('possibly corrupt in array of struct.');
+                }
+                property = new ArrayProperty(subtype, maArr, ueType, index, innerStructValueFields);
+                break;
+            default:
+                console.log(subtype, ueType);
+                throw new Error();
+        }
+        return property;
+    }
+    static CalcOverhead(property) {
+        return property.subtype.length + 5 + 1;
+    }
+    static Serialize(writer, property, propertyName) {
+        writer.writeString(property.subtype);
+        writer.writeByte(0);
+        writer.writeInt32(property.values.length);
+        switch (property.subtype) {
+            case "FloatProperty":
+                property.values.forEach(v => FloatProperty_1.FloatProperty.SerializeValue(writer, v));
+                break;
+            case "BoolProperty":
+                property.values.forEach(v => BoolProperty_1.BoolProperty.SerializeValue(writer, v));
+                break;
+            case "IntProperty":
+                property.values.forEach(v => Int32Property_1.Int32Property.SerializeValue(writer, v));
+                break;
+            case "Int64Property":
+                property.values.forEach(v => Int64Property_1.Int64Property.SerializeValue(writer, v));
+                break;
+            case "DoubleProperty":
+                property.values.forEach(v => DoubleProperty_1.DoubleProperty.SerializeValue(writer, v));
+                break;
+            case "ByteProperty":
+                property.values.forEach(v => ByteProperty_1.ByteProperty.SerializeValue(writer, v));
+                break;
+            case "StrProperty":
+                property.values.forEach(v => StrProperty_1.StrProperty.SerializeValue(writer, v));
+                break;
+            case "EnumProperty":
+                property.values.forEach(v => EnumProperty_1.EnumProperty.SerializeValue(writer, v));
+                break;
+            case "TextProperty":
+                property.values.forEach(v => TextProperty_1.TextProperty.SerializeValue(writer, v));
+                break;
+            case "InterfaceProperty":
+            case "ObjectProperty":
+                property.values.forEach(v => ObjectProperty_1.ObjectProperty.SerializeValue(writer, v));
+                break;
+            case "SoftObjectProperty":
+                property.values.forEach(v => SoftObjectReference_1.SoftObjectReference.write(writer, v));
+                break;
+            case "StructProperty":
+                writer.writeString(propertyName);
+                writer.writeString(property.subtype);
+                const lenIndicator = writer.getBufferPosition();
+                writer.writeInt32(0);
+                writer.writeInt32(property.structValueFields.allIndex);
+                writer.writeString(property.structValueFields.allStructType);
+                writer.writeInt32(property.structValueFields.allGuid);
+                writer.writeInt32(property.structValueFields.allUnk1 ?? 0);
+                writer.writeInt32(property.structValueFields.allUnk2 ?? 0);
+                writer.writeInt32(property.structValueFields.allUnk3 ?? 0);
+                writer.writeByte(property.structValueFields.allUnk4 ?? 0);
+                const before = writer.getBufferPosition();
+                property.values.forEach(v => StructProperty_1.StructProperty.SerializeValue(writer, property.structValueFields.allStructType, v.value));
+                writer.writeBinarySizeFromPosition(lenIndicator, before);
+                break;
+            default:
+                throw new Error(`Unknown array property ${property.ueType}, ${property.type}`);
+        }
+    }
+}
+exports.ArrayProperty = ArrayProperty;

package/build/parser/satisfactory/types/property/generic/BasicProperty.d.ts

@@ -0,0 +1,25 @@
+import { GUIDInfo } from '../../structs/GUIDInfo';
+export type PropertiesMap = {
+    [name: string]: AbstractBaseProperty | AbstractBaseProperty[];
+};
+export declare abstract class AbstractProperty {
+    type: string;
+    index?: number | undefined;
+    constructor(type: string, index?: number | undefined);
+}
+export declare abstract class AbstractBaseProperty extends AbstractProperty {
+    ueType: string;
+    name: string;
+    constructor(type: string, ueType: string, index: number);
+}
+type AbstractBasePropertyOptions = {
+    type: string;
+    ueType: string;
+    guidInfo?: GUIDInfo;
+    index: number;
+};
+export declare abstract class BasicProperty extends AbstractBaseProperty {
+    guidInfo: GUIDInfo;
+    constructor(options: AbstractBasePropertyOptions);
+}
+export {};

package/build/parser/satisfactory/types/property/generic/BasicProperty.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BasicProperty = exports.AbstractBaseProperty = exports.AbstractProperty = void 0;
+class AbstractProperty {
+    constructor(type, index) {
+        this.type = type;
+        this.index = index;
+    }
+}
+exports.AbstractProperty = AbstractProperty;
+class AbstractBaseProperty extends AbstractProperty {
+    constructor(type, ueType, index) {
+        super(type, index && index !== 0 ? index : undefined);
+        this.ueType = ueType;
+        this.name = '';
+    }
+}
+exports.AbstractBaseProperty = AbstractBaseProperty;
+class BasicProperty extends AbstractBaseProperty {
+    constructor(options) {
+        super(options.type, options.ueType, options.index ?? 0);
+        this.guidInfo = undefined;
+        if (options.guidInfo !== undefined) {
+            this.guidInfo = options.guidInfo;
+        }
+    }
+}
+exports.BasicProperty = BasicProperty;

package/build/parser/satisfactory/types/property/generic/BoolProperty.d.ts

@@ -0,0 +1,14 @@
+import { BinaryReadable } from '../../../../byte/binary-readable.interface';
+import { ByteWriter } from '../../../../byte/byte-writer.class';
+import { GUIDInfo } from '../../structs/GUIDInfo';
+import { BasicProperty } from './BasicProperty';
+export declare const isBoolProperty: (property: BasicProperty) => property is BoolProperty;
+export declare class BoolProperty extends BasicProperty {
+    value: boolean;
+    constructor(value: boolean, ueType?: string, guidInfo?: GUIDInfo, index?: number);
+    static Parse(reader: BinaryReadable, ueType: string, index?: number): BoolProperty;
+    static ReadValue(reader: BinaryReadable): boolean;
+    static CalcOverhead(property: BoolProperty): number;
+    static Serialize(writer: ByteWriter, property: BoolProperty): void;
+    static SerializeValue(writer: ByteWriter, value: boolean): void;
+}

package/build/parser/satisfactory/types/property/generic/BoolProperty.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BoolProperty = exports.isBoolProperty = void 0;
+const GUIDInfo_1 = require("../../structs/GUIDInfo");
+const BasicProperty_1 = require("./BasicProperty");
+const isBoolProperty = (property) => property.type === 'BoolProperty';
+exports.isBoolProperty = isBoolProperty;
+class BoolProperty extends BasicProperty_1.BasicProperty {
+    constructor(value, ueType = 'BoolProperty', guidInfo = undefined, index = 0) {
+        super({ type: 'BoolProperty', ueType, guidInfo, index });
+        this.value = value;
+    }
+    static Parse(reader, ueType, index = 0) {
+        const value = BoolProperty.ReadValue(reader);
+        const guidInfo = GUIDInfo_1.GUIDInfo.read(reader);
+        return new BoolProperty(value, ueType, guidInfo, index);
+    }
+    static ReadValue(reader) {
+        return reader.readByte() > 0;
+    }
+    static CalcOverhead(property) {
+        return 2;
+    }
+    static Serialize(writer, property) {
+        BoolProperty.SerializeValue(writer, property.value);
+        GUIDInfo_1.GUIDInfo.write(writer, property.guidInfo);
+    }
+    static SerializeValue(writer, value) {
+        writer.writeByte(value ? 1 : 0);
+    }
+}
+exports.BoolProperty = BoolProperty;

package/build/parser/satisfactory/types/property/generic/ByteProperty.d.ts

@@ -0,0 +1,18 @@
+import { BinaryReadable } from '../../../../byte/binary-readable.interface';
+import { ByteWriter } from '../../../../byte/byte-writer.class';
+import { GUIDInfo } from '../../structs/GUIDInfo';
+import { BasicProperty } from './BasicProperty';
+export declare const isByteProperty: (property: BasicProperty) => property is ByteProperty;
+export declare class ByteProperty extends BasicProperty {
+    value: BytePropertyValue;
+    constructor(value: BytePropertyValue, ueType?: string, guidInfo?: GUIDInfo, index?: number);
+    static Parse(reader: BinaryReadable, ueType: string, index?: number): ByteProperty;
+    static ReadValue(reader: BinaryReadable): number;
+    static CalcOverhead(property: ByteProperty): number;
+    static Serialize(writer: ByteWriter, property: ByteProperty): void;
+    static SerializeValue(writer: ByteWriter, value: number): void;
+}
+export type BytePropertyValue = {
+    type: string;
+    value: string | number;
+};

package/build/parser/satisfactory/types/property/generic/ByteProperty.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ByteProperty = exports.isByteProperty = void 0;
+const GUIDInfo_1 = require("../../structs/GUIDInfo");
+const BasicProperty_1 = require("./BasicProperty");
+const isByteProperty = (property) => property.type === 'ByteProperty';
+exports.isByteProperty = isByteProperty;
+class ByteProperty extends BasicProperty_1.BasicProperty {
+    constructor(value, ueType = 'ByteProperty', guidInfo = undefined, index = 0) {
+        super({ type: 'ByteProperty', ueType, guidInfo, index });
+        this.value = value;
+    }
+    static Parse(reader, ueType, index = 0) {
+        const type = reader.readString();
+        const guidInfo = GUIDInfo_1.GUIDInfo.read(reader);
+        let value;
+        if (type === 'None') {
+            value = {
+                type,
+                value: ByteProperty.ReadValue(reader)
+            };
+        }
+        else {
+            value = {
+                type,
+                value: reader.readString()
+            };
+        }
+        const property = new ByteProperty(value, ueType, guidInfo, index);
+        return property;
+    }
+    static ReadValue(reader) {
+        return reader.readByte();
+    }
+    static CalcOverhead(property) {
+        return property.value.type.length + 5 + 1;
+    }
+    static Serialize(writer, property) {
+        writer.writeString(property.value.type);
+        GUIDInfo_1.GUIDInfo.write(writer, property.guidInfo);
+        if (property.value.type === 'None') {
+            ByteProperty.SerializeValue(writer, property.value.value);
+        }
+        else {
+            writer.writeString(property.value.value);
+        }
+    }
+    static SerializeValue(writer, value) {
+        writer.writeByte(value);
+    }
+}
+exports.ByteProperty = ByteProperty;

package/build/parser/satisfactory/types/property/generic/DoubleProperty.d.ts

@@ -0,0 +1,14 @@
+import { BinaryReadable } from '../../../../byte/binary-readable.interface';
+import { ByteWriter } from '../../../../byte/byte-writer.class';
+import { GUIDInfo } from '../../structs/GUIDInfo';
+import { BasicProperty } from './BasicProperty';
+export declare const isDoubleProperty: (property: BasicProperty) => property is DoubleProperty;
+export declare class DoubleProperty extends BasicProperty {
+    value: number;
+    constructor(value: number, ueType?: string, guidInfo?: GUIDInfo, index?: number);
+    static Parse(reader: BinaryReadable, ueType: string, index?: number): DoubleProperty;
+    static ReadValue(reader: BinaryReadable): number;
+    static CalcOverhead(property: DoubleProperty): number;
+    static Serialize(writer: ByteWriter, property: DoubleProperty): void;
+    static SerializeValue(writer: ByteWriter, value: number): void;
+}

package/build/parser/satisfactory/types/property/generic/DoubleProperty.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DoubleProperty = exports.isDoubleProperty = void 0;
+const GUIDInfo_1 = require("../../structs/GUIDInfo");
+const BasicProperty_1 = require("./BasicProperty");
+const isDoubleProperty = (property) => property.type === 'DoubleProperty';
+exports.isDoubleProperty = isDoubleProperty;
+class DoubleProperty extends BasicProperty_1.BasicProperty {
+    constructor(value, ueType = 'DoubleProperty', guidInfo = undefined, index = 0) {
+        super({ type: 'DoubleProperty', ueType, guidInfo, index });
+        this.value = value;
+    }
+    static Parse(reader, ueType, index = 0) {
+        const guidInfo = GUIDInfo_1.GUIDInfo.read(reader);
+        const value = DoubleProperty.ReadValue(reader);
+        return new DoubleProperty(value, ueType, guidInfo, index);
+    }
+    static ReadValue(reader) {
+        return reader.readDouble();
+    }
+    static CalcOverhead(property) {
+        return 1;
+    }
+    static Serialize(writer, property) {
+        GUIDInfo_1.GUIDInfo.write(writer, property.guidInfo);
+        DoubleProperty.SerializeValue(writer, property.value);
+    }
+    static SerializeValue(writer, value) {
+        writer.writeDouble(value);
+    }
+}
+exports.DoubleProperty = DoubleProperty;

package/build/parser/satisfactory/types/property/generic/EnumProperty.d.ts

@@ -0,0 +1,20 @@
+import { BinaryReadable } from '../../../../byte/binary-readable.interface';
+import { ByteWriter } from '../../../../byte/byte-writer.class';
+import { GUIDInfo } from '../../structs/GUIDInfo';
+import { BasicProperty } from './BasicProperty';
+export declare const isEnumProperty: (property: BasicProperty) => property is EnumProperty;
+export declare class EnumProperty extends BasicProperty {
+    value: {
+        name: string;
+        value: string;
+    };
+    constructor(value: {
+        name: string;
+        value: string;
+    }, ueType?: string, guidInfo?: GUIDInfo, index?: number);
+    static Parse(reader: BinaryReadable, ueType: string, index?: number): EnumProperty;
+    static ReadValue(reader: BinaryReadable): string;
+    static CalcOverhead(property: EnumProperty): number;
+    static Serialize(writer: ByteWriter, property: EnumProperty): void;
+    static SerializeValue(writer: ByteWriter, value: string): void;
+}

package/build/parser/satisfactory/types/property/generic/EnumProperty.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnumProperty = exports.isEnumProperty = void 0;
+const GUIDInfo_1 = require("../../structs/GUIDInfo");
+const BasicProperty_1 = require("./BasicProperty");
+const isEnumProperty = (property) => property.type === 'EnumProperty';
+exports.isEnumProperty = isEnumProperty;
+class EnumProperty extends BasicProperty_1.BasicProperty {
+    constructor(value, ueType = 'EnumProperty', guidInfo = undefined, index = 0) {
+        super({ type: 'EnumProperty', ueType, guidInfo, index });
+        this.value = value;
+    }
+    static Parse(reader, ueType, index = 0) {
+        let name = reader.readString();
+        const guidInfo = GUIDInfo_1.GUIDInfo.read(reader);
+        const value = EnumProperty.ReadValue(reader);
+        const property = new EnumProperty({ name, value }, ueType, guidInfo, index);
+        return property;
+    }
+    static ReadValue(reader) {
+        return reader.readString();
+    }
+    static CalcOverhead(property) {
+        return property.value.name.length + 6;
+    }
+    static Serialize(writer, property) {
+        writer.writeString(property.value.name);
+        GUIDInfo_1.GUIDInfo.write(writer, property.guidInfo);
+        EnumProperty.SerializeValue(writer, property.value.value);
+    }
+    static SerializeValue(writer, value) {
+        writer.writeString(value);
+    }
+}
+exports.EnumProperty = EnumProperty;

package/build/parser/satisfactory/types/property/generic/FloatProperty.d.ts

@@ -0,0 +1,14 @@
+import { BinaryReadable } from '../../../../byte/binary-readable.interface';
+import { ByteWriter } from '../../../../byte/byte-writer.class';
+import { GUIDInfo } from '../../structs/GUIDInfo';
+import { BasicProperty } from './BasicProperty';
+export declare const isFloatProperty: (property: BasicProperty) => property is FloatProperty;
+export declare class FloatProperty extends BasicProperty {
+    value: number;
+    constructor(value: number, ueType?: string, guidInfo?: GUIDInfo, index?: number);
+    static Parse(reader: BinaryReadable, ueType: string, index?: number): FloatProperty;
+    static CalcOverhead(property: FloatProperty): number;
+    static ReadValue(reader: BinaryReadable): number;
+    static Serialize(writer: ByteWriter, property: FloatProperty): void;
+    static SerializeValue(writer: ByteWriter, value: number): void;
+}

package/build/parser/satisfactory/types/property/generic/FloatProperty.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FloatProperty = exports.isFloatProperty = void 0;
+const GUIDInfo_1 = require("../../structs/GUIDInfo");
+const BasicProperty_1 = require("./BasicProperty");
+const isFloatProperty = (property) => property.type === 'FloatProperty';
+exports.isFloatProperty = isFloatProperty;
+class FloatProperty extends BasicProperty_1.BasicProperty {
+    constructor(value, ueType = 'FloatProperty', guidInfo = undefined, index = 0) {
+        super({ type: 'FloatProperty', ueType, guidInfo, index });
+        this.value = value;
+    }
+    static Parse(reader, ueType, index = 0) {
+        const guidInfo = GUIDInfo_1.GUIDInfo.read(reader);
+        const value = FloatProperty.ReadValue(reader);
+        return new FloatProperty(value, ueType, guidInfo, index);
+    }
+    static CalcOverhead(property) {
+        return 1;
+    }
+    static ReadValue(reader) {
+        return reader.readFloat32();
+    }
+    static Serialize(writer, property) {
+        GUIDInfo_1.GUIDInfo.write(writer, property.guidInfo);
+        FloatProperty.SerializeValue(writer, property.value);
+    }
+    static SerializeValue(writer, value) {
+        writer.writeFloat32(value);
+    }
+}
+exports.FloatProperty = FloatProperty;

package/build/parser/satisfactory/types/property/generic/Int32Property.d.ts

@@ -0,0 +1,14 @@
+import { BinaryReadable } from '../../../../byte/binary-readable.interface';
+import { ByteWriter } from '../../../../byte/byte-writer.class';
+import { GUIDInfo } from '../../structs/GUIDInfo';
+import { BasicProperty } from './BasicProperty';
+export declare const isInt32Property: (property: BasicProperty) => property is Int32Property;
+export declare class Int32Property extends BasicProperty {
+    value: number;
+    constructor(value: number, ueType?: string, guidInfo?: GUIDInfo, index?: number);
+    static Parse(reader: BinaryReadable, ueType: string, index?: number): Int32Property;
+    static ReadValue(reader: BinaryReadable): number;
+    static CalcOverhead(property: Int32Property): number;
+    static Serialize(writer: ByteWriter, property: Int32Property): void;
+    static SerializeValue(writer: ByteWriter, value: number): void;
+}

package/build/parser/satisfactory/types/property/generic/Int32Property.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Int32Property = exports.isInt32Property = void 0;
+const GUIDInfo_1 = require("../../structs/GUIDInfo");
+const BasicProperty_1 = require("./BasicProperty");
+const isInt32Property = (property) => property.type === 'Int32Property';
+exports.isInt32Property = isInt32Property;
+class Int32Property extends BasicProperty_1.BasicProperty {
+    constructor(value, ueType = 'IntProperty', guidInfo = undefined, index = 0) {
+        super({ type: 'Int32Property', ueType, guidInfo, index });
+        this.value = value;
+    }
+    static Parse(reader, ueType, index = 0) {
+        const guidInfo = GUIDInfo_1.GUIDInfo.read(reader);
+        const value = Int32Property.ReadValue(reader);
+        return new Int32Property(value, ueType, guidInfo, index);
+    }
+    static ReadValue(reader) {
+        return reader.readInt32();
+    }
+    static CalcOverhead(property) {
+        return 1;
+    }
+    static Serialize(writer, property) {
+        GUIDInfo_1.GUIDInfo.write(writer, property.guidInfo);
+        Int32Property.SerializeValue(writer, property.value);
+    }
+    static SerializeValue(writer, value) {
+        writer.writeInt32(value);
+    }
+}
+exports.Int32Property = Int32Property;

package/build/parser/satisfactory/types/property/generic/Int64Property.d.ts

@@ -0,0 +1,14 @@
+import { BinaryReadable } from '../../../../byte/binary-readable.interface';
+import { ByteWriter } from '../../../../byte/byte-writer.class';
+import { GUIDInfo } from '../../structs/GUIDInfo';
+import { BasicProperty } from './BasicProperty';
+export declare const isInt64Property: (property: BasicProperty) => property is Int64Property;
+export declare class Int64Property extends BasicProperty {
+    value: string;
+    constructor(value: string, ueType?: string, guidInfo?: GUIDInfo, index?: number);
+    static Parse(reader: BinaryReadable, ueType: string, index?: number): Int64Property;
+    static ReadValue(reader: BinaryReadable): string;
+    static CalcOverhead(property: Int64Property): number;
+    static Serialize(writer: ByteWriter, property: Int64Property): void;
+    static SerializeValue(writer: ByteWriter, value: string): void;
+}

package/build/parser/satisfactory/types/property/generic/Int64Property.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Int64Property = exports.isInt64Property = void 0;
+const GUIDInfo_1 = require("../../structs/GUIDInfo");
+const BasicProperty_1 = require("./BasicProperty");
+const isInt64Property = (property) => property.type === 'Int64Property';
+exports.isInt64Property = isInt64Property;
+class Int64Property extends BasicProperty_1.BasicProperty {
+    constructor(value, ueType = 'Int64Property', guidInfo = undefined, index = 0) {
+        super({ type: 'Int64Property', ueType, guidInfo, index });
+        this.value = value;
+    }
+    static Parse(reader, ueType, index = 0) {
+        const guidInfo = GUIDInfo_1.GUIDInfo.read(reader);
+        const value = Int64Property.ReadValue(reader);
+        return new Int64Property(value, ueType, guidInfo, index);
+    }
+    static ReadValue(reader) {
+        return reader.readInt64().toString();
+    }
+    static CalcOverhead(property) {
+        return 1;
+    }
+    static Serialize(writer, property) {
+        GUIDInfo_1.GUIDInfo.write(writer, property.guidInfo);
+        Int64Property.SerializeValue(writer, property.value);
+    }
+    static SerializeValue(writer, value) {
+        writer.writeInt64(BigInt(value));
+    }
+}
+exports.Int64Property = Int64Property;

package/build/parser/satisfactory/types/property/generic/Int8Property.d.ts

@@ -0,0 +1,14 @@
+import { BinaryReadable } from '../../../../byte/binary-readable.interface';
+import { ByteWriter } from '../../../../byte/byte-writer.class';
+import { GUIDInfo } from '../../structs/GUIDInfo';
+import { BasicProperty } from './BasicProperty';
+export declare const isInt8Property: (property: BasicProperty) => property is Int8Property;
+export declare class Int8Property extends BasicProperty {
+    value: number;
+    constructor(value: number, ueType?: string, guidInfo?: GUIDInfo, index?: number);
+    static Parse(reader: BinaryReadable, ueType: string, index?: number): Int8Property;
+    static ReadValue(reader: BinaryReadable): number;
+    static CalcOverhead(property: Int8Property): number;
+    static Serialize(writer: ByteWriter, property: Int8Property): void;
+    static SerializeValue(writer: ByteWriter, value: number): void;
+}

package/build/parser/satisfactory/types/property/generic/Int8Property.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Int8Property = exports.isInt8Property = void 0;
+const GUIDInfo_1 = require("../../structs/GUIDInfo");
+const BasicProperty_1 = require("./BasicProperty");
+const isInt8Property = (property) => property.type === 'Int8Property';
+exports.isInt8Property = isInt8Property;
+class Int8Property extends BasicProperty_1.BasicProperty {
+    constructor(value, ueType = 'Int8Property', guidInfo = undefined, index = 0) {
+        super({ type: 'Int8Property', ueType, guidInfo, index });
+        this.value = value;
+    }
+    static Parse(reader, ueType, index = 0) {
+        const guidInfo = GUIDInfo_1.GUIDInfo.read(reader);
+        const value = Int8Property.ReadValue(reader);
+        return new Int8Property(value, ueType, guidInfo, index);
+    }
+    static ReadValue(reader) {
+        return reader.readInt8();
+    }
+    static CalcOverhead(property) {
+        return 1;
+    }
+    static Serialize(writer, property) {
+        GUIDInfo_1.GUIDInfo.write(writer, property.guidInfo);
+        Int8Property.SerializeValue(writer, property.value);
+    }
+    static SerializeValue(writer, value) {
+        writer.writeInt8(value);
+    }
+}
+exports.Int8Property = Int8Property;