@etothepii/satisfactory-file-parser 0.5.1 → 1.0.2

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

@@ -1,13 +0,0 @@
-import { BinaryReadable } from '../../../../byte/binary-readable.interface';
-import { ByteWriter } from '../../../../byte/byte-writer.class';
-import { GUIDInfo } from '../../GUIDInfo';
-import { BasicProperty } from './BasicProperty';
-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/objects/property/generic/Int32Property.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Int32Property = void 0;
-const GUIDInfo_1 = require("../../GUIDInfo");
-const BasicProperty_1 = require("./BasicProperty");
-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/objects/property/generic/Int64Property.d.ts

@@ -1,13 +0,0 @@
-import { BinaryReadable } from '../../../../byte/binary-readable.interface';
-import { ByteWriter } from '../../../../byte/byte-writer.class';
-import { GUIDInfo } from '../../GUIDInfo';
-import { BasicProperty } from './BasicProperty';
-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/objects/property/generic/Int64Property.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Int64Property = void 0;
-const GUIDInfo_1 = require("../../GUIDInfo");
-const BasicProperty_1 = require("./BasicProperty");
-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/objects/property/generic/Int8Property.d.ts

@@ -1,13 +0,0 @@
-import { BinaryReadable } from '../../../../byte/binary-readable.interface';
-import { ByteWriter } from '../../../../byte/byte-writer.class';
-import { GUIDInfo } from '../../GUIDInfo';
-import { BasicProperty } from './BasicProperty';
-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/objects/property/generic/Int8Property.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Int8Property = void 0;
-const GUIDInfo_1 = require("../../GUIDInfo");
-const BasicProperty_1 = require("./BasicProperty");
-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;

package/build/parser/satisfactory/objects/property/generic/MapProperty.d.ts

@@ -1,21 +0,0 @@
-import { BinaryReadable } from '../../../../byte/binary-readable.interface';
-import { ByteWriter } from '../../../../byte/byte-writer.class';
-import { ObjectReference } from '../../values/ObjectReference';
-import { BasicProperty } from './BasicProperty';
-import { GENERIC_STRUCT_PROPERTY_VALUE } from './StructProperty';
-export type MAP_STRUCT_KEY_PROXY = [number, number, number, number, number, number, number, number, number, number, number, number];
-export type GENERIC_MAP_KEY_TYPE = number | ObjectReference | boolean | GENERIC_STRUCT_PROPERTY_VALUE | MAP_STRUCT_KEY_PROXY;
-export type GENERIC_MAP_VALUE_TYPE = number | ObjectReference | boolean | GENERIC_STRUCT_PROPERTY_VALUE;
-export declare class MapProperty extends BasicProperty {
-    keyType: string;
-    valueType: string;
-    modeType: number;
-    modeUnk1: string | undefined;
-    modeUnk2: string;
-    modeUnk3: string;
-    values: [key: GENERIC_MAP_KEY_TYPE, value: GENERIC_MAP_VALUE_TYPE][];
-    constructor(keyType: string, valueType: string, ueType: string, index: number);
-    static Parse(reader: BinaryReadable, propertyName: string, buildVersion: number, size: number, ueType?: string, index?: number): MapProperty;
-    static CalcOverhead(property: MapProperty): number;
-    static Serialize(writer: ByteWriter, property: MapProperty): void;
-}

package/build/parser/satisfactory/objects/property/generic/MapProperty.js

@@ -1,160 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MapProperty = void 0;
-const BasicProperty_1 = require("./BasicProperty");
-const ByteProperty_1 = require("./ByteProperty");
-const EnumProperty_1 = require("./EnumProperty");
-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");
-class MapProperty extends BasicProperty_1.BasicProperty {
-    constructor(keyType, valueType, ueType, index) {
-        super({ type: 'MapProperty', ueType, index });
-        this.keyType = keyType;
-        this.valueType = valueType;
-        this.modeType = 0;
-        this.modeUnk2 = '';
-        this.modeUnk3 = '';
-        this.values = [];
-    }
-    static Parse(reader, propertyName, buildVersion, size, ueType = 'MapProperty', index = 0) {
-        const start = reader.getBufferPosition();
-        const property = new MapProperty(reader.readString(), reader.readString(), ueType, index);
-        const unk = reader.readByte();
-        property.modeType = reader.readInt32();
-        const elementCount = reader.readInt32();
-        for (let i = 0; i < elementCount; i++) {
-            let key;
-            let value;
-            switch (property.keyType) {
-                case 'StructProperty':
-                    if (propertyName === 'mSaveData' || propertyName === 'mUnresolvedSaveData') {
-                        key = Array.from(reader.readBytes(12));
-                    }
-                    else {
-                        key = (0, StructProperty_1.ParseDynamicStructData)(reader, 0, property.keyType);
-                    }
-                    break;
-                case 'ObjectProperty':
-                    key = ObjectProperty_1.ObjectProperty.ReadValue(reader);
-                    break;
-                case 'StrProperty':
-                case 'NameProperty':
-                    key = StrProperty_1.StrProperty.ReadValue(reader);
-                    break;
-                case 'EnumProperty':
-                    key = EnumProperty_1.EnumProperty.ReadValue(reader);
-                    break;
-                case 'IntProperty':
-                case 'Int32Property':
-                    key = Int32Property_1.Int32Property.ReadValue(reader);
-                    break;
-                case 'ByteProperty':
-                    key = ByteProperty_1.ByteProperty.ReadValue(reader);
-                    break;
-                default:
-                    throw new Error(`not implemented map key type ${property.keyType}`);
-            }
-            switch (property.valueType) {
-                case 'StructProperty':
-                    value = (0, StructProperty_1.ParseDynamicStructData)(reader, 0, property.valueType);
-                    break;
-                case 'ObjectProperty':
-                    value = ObjectProperty_1.ObjectProperty.ReadValue(reader);
-                    break;
-                case 'StrProperty':
-                case 'NameProperty':
-                    value = StrProperty_1.StrProperty.ReadValue(reader);
-                    break;
-                case 'EnumProperty':
-                    value = EnumProperty_1.EnumProperty.ReadValue(reader);
-                    break;
-                case 'IntProperty':
-                case 'Int32Property':
-                    value = Int32Property_1.Int32Property.ReadValue(reader);
-                    break;
-                case 'Int64Property':
-                    value = Int64Property_1.Int64Property.ReadValue(reader);
-                    break;
-                case 'ByteProperty':
-                    value = ByteProperty_1.ByteProperty.ReadValue(reader);
-                    break;
-                default:
-                    throw new Error(`not implemented map value type ${property.valueType}`);
-            }
-            property.values.push([key, value]);
-        }
-        return property;
-    }
-    static CalcOverhead(property) {
-        return property.keyType.length + 5 + property.valueType.length + 5 + 1;
-    }
-    static Serialize(writer, property) {
-        writer.writeString(property.keyType);
-        writer.writeString(property.valueType);
-        writer.writeByte(0);
-        writer.writeInt32(property.modeType);
-        writer.writeInt32(property.values.length);
-        for (const entry of property.values) {
-            switch (property.keyType) {
-                case 'StructProperty':
-                    if (property.name === 'mSaveData' || property.name === 'mUnresolvedSaveData') {
-                        writer.writeBytesArray(entry[0]);
-                    }
-                    else {
-                        (0, StructProperty_1.SerializeDynamicStructData)(writer, 0, entry[0]);
-                    }
-                    break;
-                case 'ObjectProperty':
-                    ObjectProperty_1.ObjectProperty.SerializeValue(writer, entry[0]);
-                    break;
-                case 'StrProperty':
-                case 'NameProperty':
-                    StrProperty_1.StrProperty.SerializeValue(writer, entry[0]);
-                    break;
-                case 'EnumProperty':
-                    EnumProperty_1.EnumProperty.SerializeValue(writer, entry[0]);
-                    break;
-                case 'IntProperty':
-                case 'Int32Property':
-                    Int32Property_1.Int32Property.SerializeValue(writer, entry[0]);
-                    break;
-                case 'ByteProperty':
-                    ByteProperty_1.ByteProperty.SerializeValue(writer, entry[0]);
-                    break;
-                default:
-                    throw new Error(`not implemented map key type ${property.valueType}`);
-            }
-            switch (property.valueType) {
-                case 'StructProperty':
-                    (0, StructProperty_1.SerializeDynamicStructData)(writer, 0, entry[1]);
-                    break;
-                case 'ObjectProperty':
-                    ObjectProperty_1.ObjectProperty.SerializeValue(writer, entry[1]);
-                    break;
-                case 'StrProperty':
-                case 'NameProperty':
-                    StrProperty_1.StrProperty.SerializeValue(writer, entry[1]);
-                    break;
-                case 'EnumProperty':
-                    EnumProperty_1.EnumProperty.SerializeValue(writer, entry[1]);
-                    break;
-                case 'IntProperty':
-                case 'Int32Property':
-                    Int32Property_1.Int32Property.SerializeValue(writer, entry[1]);
-                    break;
-                case 'Int64Property':
-                    Int64Property_1.Int64Property.SerializeValue(writer, entry[1]);
-                    break;
-                case 'ByteProperty':
-                    ByteProperty_1.ByteProperty.SerializeValue(writer, entry[1]);
-                    break;
-                default:
-                    throw new Error(`not implemented map value type ${property.valueType}`);
-            }
-        }
-    }
-}
-exports.MapProperty = MapProperty;

package/build/parser/satisfactory/objects/property/generic/ObjectProperty.d.ts

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

package/build/parser/satisfactory/objects/property/generic/ObjectProperty.js

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

package/build/parser/satisfactory/objects/property/generic/SetProperty.d.ts

@@ -1,11 +0,0 @@
-import { BinaryReadable } from '../../../../byte/binary-readable.interface';
-import { ByteWriter } from '../../../../byte/byte-writer.class';
-import { BasicProperty } from './BasicProperty';
-export declare class SetProperty<T> extends BasicProperty {
-    subtype: string;
-    values: T[];
-    constructor(subtype: string, values: T[], ueType: string, index: number);
-    static Parse(reader: BinaryReadable, ueType: string, index: number, propertyName: string): SetProperty<any>;
-    static CalcOverhead(property: SetProperty<any>): number;
-    static Serialize(writer: ByteWriter, property: SetProperty<any>): void;
-}

package/build/parser/satisfactory/objects/property/generic/SetProperty.js

@@ -1,92 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SetProperty = void 0;
-const util_types_1 = require("../../../structs/util.types");
-const GUID_1 = require("../../values/GUID");
-const BasicProperty_1 = require("./BasicProperty");
-const Int32Property_1 = require("./Int32Property");
-const ObjectProperty_1 = require("./ObjectProperty");
-const StrProperty_1 = require("./StrProperty");
-const Uint32Property_1 = require("./Uint32Property");
-class SetProperty extends BasicProperty_1.BasicProperty {
-    constructor(subtype, values, ueType, index) {
-        super({ type: 'SetProperty', ueType, index });
-        this.subtype = subtype;
-        this.values = values;
-    }
-    static Parse(reader, ueType, index, propertyName) {
-        const subtype = reader.readString();
-        const unk2 = reader.skipBytes(1);
-        const unk3 = reader.skipBytes(4);
-        const elementCount = reader.readInt32();
-        let property;
-        switch (subtype) {
-            case "UInt32Property":
-                property = new SetProperty(subtype, new Array(elementCount).fill(0).map(() => Uint32Property_1.Uint32Property.ReadValue(reader)), ueType, index);
-                break;
-            case "IntProperty":
-                property = new SetProperty(subtype, new Array(elementCount).fill(0).map(() => Int32Property_1.Int32Property.ReadValue(reader)), ueType, index);
-                break;
-            case "ObjectProperty":
-                property = new SetProperty(subtype, new Array(elementCount).fill(0).map(() => ObjectProperty_1.ObjectProperty.ReadValue(reader)), ueType, index);
-                break;
-            case "NameProperty":
-                property = new SetProperty(subtype, new Array(elementCount).fill(0).map(() => StrProperty_1.StrProperty.ReadValue(reader)), ueType, index);
-                break;
-            case "StructProperty":
-                if (propertyName === 'mRemovalLocations') {
-                    property = new SetProperty(subtype, new Array(elementCount).fill(0).map(() => util_types_1.vec3.ParseF(reader)), ueType, index);
-                }
-                if (propertyName === 'mDestroyedPickups' || propertyName === 'mLootedDropPods') {
-                    property = new SetProperty(subtype, new Array(elementCount).fill(0).map(() => GUID_1.GUID.read(reader)), ueType, index);
-                }
-                else {
-                    throw new Error(`Not Implemented SetProperty of StructProperty for property ${propertyName}.`);
-                }
-                break;
-            default:
-                throw new Error(`Not Implemented SetProperty of ${subtype}.`);
-        }
-        return property;
-    }
-    static CalcOverhead(property) {
-        return property.subtype.length + 5 + 1;
-    }
-    static Serialize(writer, property) {
-        writer.writeString(property.subtype);
-        writer.writeByte(0);
-        writer.writeInt32(0);
-        writer.writeInt32(property.values.length);
-        switch (property.subtype) {
-            case "IntProperty":
-            case "Int32Property":
-                property.values.forEach(v => Int32Property_1.Int32Property.SerializeValue(writer, v));
-                break;
-            case "UIntProperty":
-            case "UInt32Property":
-                property.values.forEach(v => Uint32Property_1.Uint32Property.SerializeValue(writer, v));
-                break;
-            case "ObjectProperty":
-                property.values.forEach(v => ObjectProperty_1.ObjectProperty.SerializeValue(writer, v));
-                break;
-            case "NameProperty":
-                property.values.forEach(v => StrProperty_1.StrProperty.SerializeValue(writer, v));
-                break;
-            case "StructProperty":
-                if (property.name === 'mRemovalLocations') {
-                    console.warn('serializing mRemovalLocations, this is still under investigation.');
-                    property.values.forEach(v => util_types_1.vec3.SerializeF(writer, v));
-                }
-                else if (property.name === 'mDestroyedPickups' || property.name === 'mLootedDropPods') {
-                    property.values.forEach(v => GUID_1.GUID.write(writer, v));
-                }
-                else {
-                    throw new Error(`Not Implemented serializing SetProperty of StructProperty for property ${property.name}.`);
-                }
-                break;
-            default:
-                throw new Error(`Not Implemented SetProperty of ${property.subtype}.`);
-        }
-    }
-}
-exports.SetProperty = SetProperty;

package/build/parser/satisfactory/objects/property/generic/SoftObjectProperty.d.ts

@@ -1,12 +0,0 @@
-import { BinaryReadable } from '../../../../byte/binary-readable.interface';
-import { ByteWriter } from '../../../../byte/byte-writer.class';
-import { GUIDInfo } from '../../GUIDInfo';
-import { SoftObjectReference } from '../../values/SoftObjectReference';
-import { BasicProperty } from './BasicProperty';
-export declare class SoftObjectProperty extends BasicProperty {
-    value: SoftObjectReference;
-    constructor(value: SoftObjectReference, ueType?: string, guidInfo?: GUIDInfo, index?: number);
-    static Parse(reader: BinaryReadable, ueType: string, index?: number): SoftObjectProperty;
-    static CalcOverhead(property: SoftObjectProperty): number;
-    static Serialize(writer: ByteWriter, property: SoftObjectProperty): void;
-}

package/build/parser/satisfactory/objects/property/generic/SoftObjectProperty.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SoftObjectProperty = void 0;
-const GUIDInfo_1 = require("../../GUIDInfo");
-const SoftObjectReference_1 = require("../../values/SoftObjectReference");
-const BasicProperty_1 = require("./BasicProperty");
-class SoftObjectProperty extends BasicProperty_1.BasicProperty {
-    constructor(value, ueType = 'SoftObjectProperty', guidInfo = undefined, index = 0) {
-        super({ type: 'SoftObjectProperty', ueType, guidInfo, index });
-        this.value = value;
-    }
-    static Parse(reader, ueType, index = 0) {
-        const guidInfo = GUIDInfo_1.GUIDInfo.read(reader);
-        const value = SoftObjectReference_1.SoftObjectReference.read(reader);
-        return new SoftObjectProperty(value, ueType, guidInfo, index);
-    }
-    static CalcOverhead(property) {
-        return 1;
-    }
-    static Serialize(writer, property) {
-        GUIDInfo_1.GUIDInfo.write(writer, property.guidInfo);
-        SoftObjectReference_1.SoftObjectReference.write(writer, property.value);
-    }
-}
-exports.SoftObjectProperty = SoftObjectProperty;

package/build/parser/satisfactory/objects/property/generic/StrProperty.d.ts

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

package/build/parser/satisfactory/objects/property/generic/StrProperty.js

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

package/build/parser/satisfactory/objects/property/generic/StructProperty.d.ts

@@ -1,66 +0,0 @@
-import { BinaryReadable } from '../../../../byte/binary-readable.interface';
-import { ByteWriter } from '../../../../byte/byte-writer.class';
-import { col4, vec3, vec4 } from '../../../structs/util.types';
-import { AbstractBaseProperty, PropertiesMap } from './BasicProperty';
-export type BasicMultipleStructPropertyValue = {
-    values: any;
-};
-export type BasicStructPropertyValue = {
-    value: any;
-};
-export type BoxStructPropertyValue = {
-    min: vec3;
-    max: vec3;
-    isValid: boolean;
-};
-export type RailroadTrackPositionStructPropertyValue = {
-    root: string;
-    instanceName: string;
-    offset: number;
-    forward: number;
-};
-export type InventoryItemStructPropertyValue = {
-    unk1: number;
-    itemName: string;
-    hasItemState: number;
-    itemState?: {
-        unk: number;
-        pathName: string;
-        binarySize: number;
-        itemStateRaw: number[];
-    };
-};
-export type FICFrameRangeStructPropertyValue = {
-    begin: string;
-    end: string;
-};
-export type DynamicStructPropertyValue = {
-    type: string;
-    properties: PropertiesMap;
-};
-export type ClientIdentityInfo = {
-    offlineId: string;
-    accountIds: Record<number, number[]>;
-};
-export type GENERIC_STRUCT_PROPERTY_VALUE = BasicMultipleStructPropertyValue | BasicStructPropertyValue | BoxStructPropertyValue | RailroadTrackPositionStructPropertyValue | InventoryItemStructPropertyValue | FICFrameRangeStructPropertyValue | ClientIdentityInfo | DynamicStructPropertyValue | col4 | vec3 | vec4 | string;
-export declare class StructProperty extends AbstractBaseProperty {
-    subtype: string;
-    guid: number;
-    value: GENERIC_STRUCT_PROPERTY_VALUE;
-    unk1?: number;
-    unk2?: number;
-    unk3?: number;
-    unk4?: number;
-    constructor(subtype: string, ueType?: string, index?: number, guid?: number);
-    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: ByteWriter, property: StructProperty): void;
-    static SerializeValue(writer: ByteWriter, subtype: string, value: GENERIC_STRUCT_PROPERTY_VALUE): 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;