@bikky/replication 1.0.1

package/Constants/Errors.d.ts

@@ -0,0 +1,27 @@
+import { EAST_Token, ExpressionGrammar } from "../Expressions/Compiler/ExpressionGrammar.js";
+import { ExpressionAST } from "../Expressions/Compiler/BuiltinGrammar.js";
+import ExpressionNode = ExpressionAST.ExpressionNode;
+import Node = ExpressionGrammar.Node;
+import { SourceMap } from "./SourceMaps.js";
+export declare class ErrorStack {
+    errorStack: string[];
+    errorLocations: string[];
+    source: SourceMap;
+    constructor(source: SourceMap);
+    hasErrors(): boolean;
+    add(code: string, msg: string): this;
+    toString(locCode: string): string;
+    appendWithoutIndent(other: ErrorStack): this;
+    appendAndIndent(other: ErrorStack): this;
+}
+export interface ExpressionSource {
+    text: string;
+    file: string;
+    line: number;
+}
+export declare class ExpressionSyntaxError extends Error {
+    source: ExpressionSource;
+    location: number;
+    constructor(msg: string, source: ExpressionSource, location: number);
+    constructor(msg: string, node: EAST_Token | ExpressionNode | Node);
+}

package/Constants/Errors.js

@@ -0,0 +1,75 @@
+import { BikPath } from "@bikky/path";
+let stacks = new Map();
+export class ErrorStack {
+    constructor(source) {
+        this.errorLocations = [];
+        this.source = source;
+        this.errorStack = [];
+    }
+    hasErrors() {
+        return this.errorStack.length > 0;
+    }
+    add(code, msg) {
+        this.errorStack.push(msg);
+        if (this.errorLocations.length == 0) {
+            let newTrace = stacks.get(code);
+            if (!newTrace) {
+                stacks.set(code, newTrace = new Error().stack);
+            }
+            newTrace = newTrace.replace(/^(Error: )\n.*/, "$1").replace(/\.js/g, ".ts");
+            this.errorLocations.push(newTrace);
+        }
+        return this;
+    }
+    toString(locCode) {
+        if (this.errorStack.length == 0)
+            return "";
+        if (this.errorLocations.length == 0) {
+            let localErr = stacks.get(locCode);
+            if (!localErr) {
+                localErr = new Error().stack;
+                stacks.set(locCode, localErr);
+            }
+            localErr = localErr.replace(/^(Error: )\n.*/, "$1").replace(/\.js/g, ".ts");
+            this.errorLocations.push(localErr);
+        }
+        return this.errorStack.join("\n") + "\n\n"
+            + " at Mod (" + BikPath.fsStyle(this.source.SourceFile).replace(".js", ".ts") + ":0:0)\n\n"
+            + (this.errorLocations.join("\n\n"))
+            + "\n";
+    }
+    appendWithoutIndent(other) {
+        this.errorStack = this.errorStack.concat(...other.errorStack);
+        this.errorLocations.push(...other.errorLocations);
+        return this;
+    }
+    appendAndIndent(other) {
+        this.errorStack = this.errorStack.concat(...other.errorStack.map((e) => "\t" + e));
+        this.errorLocations.push(...other.errorLocations);
+        return this;
+    }
+}
+function MarkIncidentLocation(source, location) {
+    return ` ---> ${source.text}\n      ${"".padStart(location, " ")}^^\nFound in file ${source.file} on line ${source.line} at ${location}.\n`;
+}
+export class ExpressionSyntaxError extends Error {
+    constructor(msg, source, location) {
+        if (location) {
+            super(msg + `\n${MarkIncidentLocation(source, location)}`);
+            this.source = source;
+            this.location = location;
+        }
+        else {
+            let node = source;
+            let sourceDetails = {
+                file: node.file.sourceLocation,
+                version: node.file.version,
+                text: node.file.text,
+                line: node.line
+            };
+            super(msg + `\n${MarkIncidentLocation(sourceDetails, node.column)}`);
+            this.source = sourceDetails;
+            this.location = node.column;
+        }
+    }
+}

package/Constants/Logging.d.ts

@@ -0,0 +1,17 @@
+declare global {
+    interface Console {
+        logLevel: Logging.Verbosity | "none" | "errors" | "warnings" | "info" | "debug";
+    }
+}
+export declare namespace Logging {
+    enum Verbosity {
+        None = 0,
+        Log = 1,
+        Error = 2,
+        Warning = 3,
+        Info = 4,
+        Debug = 5
+    }
+    function SetVerbosityLevel(level: Verbosity, path?: string): void;
+    function SetVerbosityLevelForDirectory(level: Verbosity, directory: string): void;
+}

package/Constants/Logging.js

@@ -0,0 +1,97 @@
+import { BikPath } from "@bikky/path";
+export var Logging;
+(function (Logging) {
+    let Verbosity;
+    (function (Verbosity) {
+        Verbosity[Verbosity["None"] = 0] = "None";
+        Verbosity[Verbosity["Log"] = 1] = "Log";
+        Verbosity[Verbosity["Error"] = 2] = "Error";
+        Verbosity[Verbosity["Warning"] = 3] = "Warning";
+        Verbosity[Verbosity["Info"] = 4] = "Info";
+        Verbosity[Verbosity["Debug"] = 5] = "Debug";
+    })(Verbosity = Logging.Verbosity || (Logging.Verbosity = {}));
+    const OriginalLog = console.log;
+    const OriginalWarn = console.warn;
+    const OriginalError = console.error;
+    const OriginalInfo = console.info;
+    const OriginalDebug = console.debug;
+    const OriginalAssert = console.assert;
+    const DirectoryVerbosityLevel = new Map();
+    const FileVerbosityLevel = new Map();
+    function ComputeVerbosity() {
+        var _a;
+        let file = (_a = BikPath.GetStackFrame(2)) === null || _a === void 0 ? void 0 : _a.file;
+        if (!file) {
+            return Verbosity.Warning;
+        }
+        if (FileVerbosityLevel.has(file)) {
+            return FileVerbosityLevel.get(file);
+        }
+        let directories = file.split("/");
+        for (let i = directories.length; i > 0; i--) {
+            let directory = directories[i];
+            if (DirectoryVerbosityLevel.has(directory)) {
+                return DirectoryVerbosityLevel.get(directory);
+            }
+        }
+        return Verbosity.Warning;
+    }
+    Object.defineProperty(console, "logLevel", {
+        get() {
+            return ComputeVerbosity();
+        },
+        set(value) {
+            if (typeof value === "number") {
+                return FileVerbosityLevel.set(BikPath.getCallerFilepath(), value);
+            }
+            if (value === value.toLowerCase()) {
+                value = value[0].toUpperCase() + value.slice(1);
+            }
+            return FileVerbosityLevel.set(BikPath.getCallerFilepath(), Verbosity[value]);
+        }
+    });
+    function SetVerbosityLevel(level, path) {
+        let file = BikPath.getCallerFilepath();
+        if (path) {
+            file = BikPath.join(file, path);
+        }
+        FileVerbosityLevel.set(file, level);
+    }
+    Logging.SetVerbosityLevel = SetVerbosityLevel;
+    function SetVerbosityLevelForDirectory(level, directory) {
+        DirectoryVerbosityLevel.set(directory, level);
+    }
+    Logging.SetVerbosityLevelForDirectory = SetVerbosityLevelForDirectory;
+    console.log = function (...args) {
+        if (ComputeVerbosity() >= Verbosity.Log) {
+            OriginalLog(...args);
+        }
+    };
+    console.warn = function (...args) {
+        if (ComputeVerbosity() >= Verbosity.Warning) {
+            OriginalWarn(...args);
+        }
+    };
+    console.error = function (...args) {
+        if (ComputeVerbosity() >= Verbosity.Error) {
+            OriginalError(...args);
+        }
+    };
+    console.info = function (...args) {
+        if (ComputeVerbosity() >= Verbosity.Info) {
+            OriginalInfo(...args);
+        }
+    };
+    console.debug = function (...args) {
+        if (ComputeVerbosity() >= Verbosity.Debug) {
+            OriginalDebug(...args);
+        }
+    };
+    console.assert = function (condition, ...args) {
+        if (!condition) {
+            if (ComputeVerbosity() >= Verbosity.Error) {
+                OriginalAssert(condition, ...args);
+            }
+        }
+    };
+})(Logging || (Logging = {}));

package/Constants/ReplicableRegistry.d.ts

@@ -0,0 +1,37 @@
+import { Class } from "@bikky/smart-collections";
+import { Primitive } from "./SerialisationTypes.js";
+import type { ReplicableClass } from "../Tracking/Class.js";
+import type { CustomClass } from "../Tracking/Types.js";
+export declare namespace ReplicableRegistry {
+    function Initialise(): Promise<void>;
+    /**
+     * This function is only for testing!
+     */
+    function triggerLoadCompleteForTests(): Promise<void>;
+    function ResetForTests(): Promise<void>;
+    /**
+     * Add idToMap as an alias for the given replicable class. E.g. adding
+     * Array as a pointer to a custom array resolver would have Array as the first value, then the resolver
+     * (or it's name) as the second. From then-on you could use type: Array in @Property and get the resolver.
+     * @param idToMap the name or object you want to use as an alias for another class.
+     * @param replicableValue the class you want to use to resolve loading/saving and replicating the value.
+     */
+    function RegisterTypeAlias(idToMap: string | {
+        name?: string;
+    }, replicableValue: Class<any> | AbstractClass<any> | CustomClass | string | Primitive): void;
+    function ReplaceClass(oldClass: any, newClass: any): void;
+    function MarkLoadStarted(markerName: string): Promise<void>;
+    function MarkLoadComplete(markerName: string): Promise<void>;
+    function __GetReplicablesFor(type: any): (ReplicableClass | Primitive)[] | undefined;
+    function __GetReplOrPrimFor(type: any): (ReplicableClass | Primitive)[] | undefined;
+    function __GetReplicableForDataName(type: string): ReplicableClass | undefined;
+    function __GetAllReplicables(): ReplicableClass[];
+    function __TypesToReplicables(types: (Class<any> | string)[]): any[];
+    function GetDataNameOfObjectType(obj: object): string;
+    function GetDataName(type: Class<any>): string;
+    function GetTypesForName(type: string): any;
+    function GetTypeForDataName(type: string): ReplicableClass | undefined;
+    function HasType(type: Class<any>): any;
+    function IsType<T>(object: any, type: Class<T>): object is T;
+    function IsType(object: any, type: string): boolean;
+}

package/Constants/ReplicableRegistry.js

@@ -0,0 +1,234 @@
+import { ArrayMap, InheritableArrayMetastore, OpenPromise, SmartArray, } from "@bikky/smart-collections";
+import { describeObject, getPrimitiveClass, isPrimitiveType, TypeSymbol, } from "./SerialisationTypes.js";
+import { Progress } from "../Transformers/Progress.js";
+import { Logging } from "./Logging.js";
+const InheritanceMap = new InheritableArrayMetastore("TypeParent");
+//This is an array because you can have type aliases that link to multiple types
+// E.g. Location -> InventorySlot, Entity, Tile, null, etc.
+const TypeMap = new ArrayMap();
+const DataNameMap = new Map();
+const ParentSymbol = Symbol("parent");
+export var ReplicableRegistry;
+(function (ReplicableRegistry) {
+    console.logLevel = Logging.Verbosity.None;
+    //Keep a list of all the repliable types that have been registered,
+    // as they finish load mark them off the list.
+    // When the list is empty or the list hasn't changed for a period of time.
+    // Mark load as complete and complain about all of the types that haven't been loaded.
+    let pendingTypes = new SmartArray();
+    let loadComplete = new OpenPromise();
+    let loadBegun = false;
+    let loadTimeout = null;
+    let externalLoadingMarkers = [];
+    function OnLoadComplete() {
+        if (externalLoadingMarkers.length > 0) {
+            ResetLoadTimeout();
+            return;
+        }
+        clearTimeout(loadTimeout);
+        loadBegun = true;
+        Progress.FinishedAllLoading();
+        if (pendingTypes.length > 0) {
+            let typeNames = new Set(pendingTypes.map((type) => typeof type === "string" ? type.replace("Definition", "") :
+                typeof type === "function" ? type.name : "" + type));
+            console.warn("Types that failed to load because their dependancies didn't load: ", [...typeNames].join(", "));
+            // console.log("Replacing all types that didn't load with unknown.");
+            // let unknown = __getReplicableFor("unknown")!;
+            // for (let type of pendingTypes) {
+            //     typeMap.set(type, unknown);
+            //     typeFinishedLoad.resolve(type, unknown);
+            // }
+        }
+        console.info("Replicable Types load complete.");
+        loadComplete.complete();
+    }
+    function ResetLoadTimeout() {
+        if (loadTimeout !== null)
+            clearTimeout(loadTimeout);
+        loadTimeout = setTimeout(() => {
+            //If load finishes immediately (e.g. because of tests) this can still trigger.
+            if (loadBegun === false) {
+                OnLoadComplete();
+            }
+        }, 100);
+    }
+    async function Initialise() {
+        OnLoadComplete();
+        await loadComplete;
+    }
+    ReplicableRegistry.Initialise = Initialise;
+    /**
+     * This function is only for testing!
+     */
+    async function triggerLoadCompleteForTests() {
+        if (typeof TestingMode === "boolean" && TestingMode) {
+            OnLoadComplete();
+        }
+    }
+    ReplicableRegistry.triggerLoadCompleteForTests = triggerLoadCompleteForTests;
+    async function ResetForTests() {
+        loadComplete = new OpenPromise();
+        loadBegun = false;
+        externalLoadingMarkers.length = 0;
+        // pendingTypes = new SmartArray<any>();
+        // TypeMap.clear();
+        // DataNameMap.clear();
+        Progress.ClearCaches();
+    }
+    ReplicableRegistry.ResetForTests = ResetForTests;
+    function OnTypeLoaded(type, originalClass) {
+        console.info(`${Date.now()}: Finished loading ${type.opts.typescriptTypeName}`);
+        //Support for @DelayUntil classes.
+        if (!TypeMap.includes(originalClass, type)) {
+            TypeMap.push(originalClass, type);
+        }
+        if (!TypeMap.includes(type.classConstructor, type)) {
+            TypeMap.push(type.classConstructor, type);
+        }
+        if (!TypeMap.includes(type.opts.dataTypeName, type)) {
+            TypeMap.push(type.opts.dataTypeName, type);
+        }
+        DataNameMap.set(type.opts.dataTypeName, type);
+        if (!TypeMap.includes(type.opts.typescriptTypeName, type)) {
+            TypeMap.push(type.opts.typescriptTypeName, type);
+        }
+        if (!isPrimitiveType(type.classConstructor)) {
+            InheritanceMap.add(type.classConstructor, ParentSymbol, type);
+        }
+        ResetLoadTimeout();
+    }
+    function OnAliasLoaded(alias, types) {
+        for (let type of types) {
+            if (!TypeMap.includes(alias, type)) {
+                TypeMap.push(alias, type);
+            }
+        }
+        pendingTypes.removeAll(alias, alias.name);
+        ResetLoadTimeout();
+    }
+    Progress.OnAnyReplicableReady(OnTypeLoaded);
+    Progress.OnAnyPrimitiveReady((alias, prim) => {
+        TypeMap.push(alias, prim);
+        pendingTypes.removeAll(alias);
+        ResetLoadTimeout();
+    });
+    Progress.OnAnyAliasReady(OnAliasLoaded);
+    /**
+     * Add idToMap as an alias for the given replicable class. E.g. adding
+     * Array as a pointer to a custom array resolver would have Array as the first value, then the resolver
+     * (or it's name) as the second. From then-on you could use type: Array in @Property and get the resolver.
+     * @param idToMap the name or object you want to use as an alias for another class.
+     * @param replicableValue the class you want to use to resolve loading/saving and replicating the value.
+     */
+    function RegisterTypeAlias(idToMap, replicableValue) {
+        Progress.RegisterAlias(idToMap, replicableValue);
+    }
+    ReplicableRegistry.RegisterTypeAlias = RegisterTypeAlias;
+    OnBikDelayCompleted(function UpdateRegistryClasses(old, upd) {
+        RegisterTypeAlias(old, upd);
+        let mapping = TypeMap.get(old);
+        if (mapping) {
+            TypeMap.set(upd, mapping);
+        }
+    });
+    function ReplaceClass(oldClass, newClass) {
+        let oldTypes = TypeMap.get(oldClass), newTypes = TypeMap.get(newClass);
+        if (!newTypes) {
+            throw new Error(`Cannot override type ${oldClass.name} with ${newClass.name} as ${newClass.name} is not registered.`);
+        }
+        if (!oldTypes) {
+            throw new Error(`Cannot override type ${oldClass.name} with ${newClass.name} as ${oldClass.name} is not registered.`);
+        }
+        let oldType = oldTypes.find((e) => !isPrimitiveType(e) && e.classConstructor == oldClass);
+        let newType = newTypes.find((e) => !isPrimitiveType(e) && e.classConstructor == oldClass);
+        TypeMap.remove(oldType.classConstructor, oldType);
+        TypeMap.push(oldType.classConstructor, newType);
+        TypeMap.remove(oldType.opts.dataTypeName, oldType);
+        TypeMap.push(oldType.opts.dataTypeName, newType);
+        DataNameMap.set(oldType.opts.dataTypeName, newType);
+        TypeMap.remove(oldType.opts.typescriptTypeName, oldType);
+        TypeMap.push(oldType.opts.typescriptTypeName, newType);
+        TypeMap.set(oldType.opts.typescriptTypeName, new SmartArray(newType));
+    }
+    ReplicableRegistry.ReplaceClass = ReplaceClass;
+    async function MarkLoadStarted(markerName) {
+        externalLoadingMarkers.push(markerName);
+        console.debug("Started loading", markerName);
+    }
+    ReplicableRegistry.MarkLoadStarted = MarkLoadStarted;
+    async function MarkLoadComplete(markerName) {
+        if (!externalLoadingMarkers.includes(markerName)) {
+            throw new Error("Can't mark loading as complete for marker that hasn't started.");
+        }
+        console.debug("Completed loading", markerName);
+        externalLoadingMarkers.splice(externalLoadingMarkers.indexOf(markerName));
+        if (externalLoadingMarkers.length == 0) {
+            ResetLoadTimeout();
+        }
+    }
+    ReplicableRegistry.MarkLoadComplete = MarkLoadComplete;
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    function __GetReplicablesFor(type) {
+        if (!TypeMap.has(type)) {
+            console.warn(`Unable to find type ${describeObject(type)} in type map, is it missing a @Type or @Struct decorator?`);
+        }
+        let result = TypeMap.get(type);
+        return result;
+    }
+    ReplicableRegistry.__GetReplicablesFor = __GetReplicablesFor;
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    function __GetReplOrPrimFor(type) {
+        let result = isPrimitiveType(type) ? [type] : TypeMap.get(type);
+        if (!result) {
+            console.warn(`Unable to find type ${describeObject(type)} in type map, is it missing a @Type or @Struct decorator?`);
+        }
+        return result;
+    }
+    ReplicableRegistry.__GetReplOrPrimFor = __GetReplOrPrimFor;
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    function __GetReplicableForDataName(type) {
+        return DataNameMap.get(type);
+    }
+    ReplicableRegistry.__GetReplicableForDataName = __GetReplicableForDataName;
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    function __GetAllReplicables() {
+        return Array.from(new Set(TypeMap.values()))
+            .flat()
+            .filter((e) => !!e && !isPrimitiveType(e));
+    }
+    ReplicableRegistry.__GetAllReplicables = __GetAllReplicables;
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    function __TypesToReplicables(types) {
+        return types.flatMap((e) => { var _a; return (_a = TypeMap.get(e)) !== null && _a !== void 0 ? _a : []; });
+    }
+    ReplicableRegistry.__TypesToReplicables = __TypesToReplicables;
+    function GetDataNameOfObjectType(obj) {
+        var _a;
+        return (_a = obj[TypeSymbol]) === null || _a === void 0 ? void 0 : _a.opts.dataTypeName;
+    }
+    ReplicableRegistry.GetDataNameOfObjectType = GetDataNameOfObjectType;
+    function GetDataName(type) {
+        var _a;
+        return (_a = type.prototype[TypeSymbol]) === null || _a === void 0 ? void 0 : _a.opts.dataTypeName;
+    }
+    ReplicableRegistry.GetDataName = GetDataName;
+    function GetTypesForName(type) {
+        var _a;
+        return (_a = TypeMap.get(type)) === null || _a === void 0 ? void 0 : _a.map((e) => isPrimitiveType(e) ? e : e.classConstructor);
+    }
+    ReplicableRegistry.GetTypesForName = GetTypesForName;
+    function GetTypeForDataName(type) {
+        return DataNameMap.get(type);
+    }
+    ReplicableRegistry.GetTypeForDataName = GetTypeForDataName;
+    function HasType(type) {
+        return TypeMap.has(type);
+    }
+    ReplicableRegistry.HasType = HasType;
+    function IsType(object, type) {
+        let typeDefs = TypeMap.get(type);
+        let isPrimitive = typeof object !== "object" || object == null;
+        return !!(typeDefs === null || typeDefs === void 0 ? void 0 : typeDefs.some((e) => isPrimitiveType(e) ? isPrimitive ? getPrimitiveClass(object) === e : false : e === null || e === void 0 ? void 0 : e.isObjectOfThisType(object)));
+    }
+    ReplicableRegistry.IsType = IsType;
+})(ReplicableRegistry || (ReplicableRegistry = {}));

package/Constants/SerialisationTypes.d.ts

@@ -0,0 +1,82 @@
+import { Class } from "@bikky/smart-collections";
+import { Pointer } from "../Transformers/Reference.js";
+import { Versions } from "./Versions.js";
+import { TraversalStep } from "./TraversalStep.js";
+import { ReplicableClass } from "../Tracking/Class.js";
+export declare function getClassOfObject<T extends any>(obj: T): Class<T>;
+export declare function generateDataName(name: string): string;
+export declare function describeObject(type: any): string;
+export declare function describeObjects(types: any[], brackets?: boolean): string;
+export type DataType<T extends object = {}> = StructDataType<T> & {
+    ID: string;
+    Class: string;
+    Version: Versions | string;
+    SourceFile: string;
+};
+export type StructDataType<T extends object = {}> = Omit<{
+    [K in keyof T as T[K] extends Function ? never : Capitalize<string & K>]?: DataTSType<T[K]> | string;
+}, "Id">;
+export type DataTSType<T = {}> = T extends string | number | boolean | void | undefined ? T : T extends Pointer<infer J> ? DataTSType<J> : T extends object ? {
+    [K in keyof T as K extends string ? Capitalize<K> : never]?: DataTSType<T[K]> | T[K];
+} | T : T extends Function ? T extends Function & {
+    prototype: infer J;
+} ? DataTSType<J> | J : T extends {
+    new (...args: any[]): infer J;
+} ? DataTSType<J> | J : never : never;
+export type getObjectReferenceType<T extends Object> = TraversalStep | SerialisedType<T>;
+export type SerialisedType<T extends Object> = {
+    [K in Exclude<keyof T, "id"> as T[K] extends Function ? never : Capitalize<string & K>]: SerialisedTSType<T[K]>;
+} & {
+    INST_ID?: string;
+    INST_REF: [type: string, ...extra: any[]];
+    Version: string;
+};
+export type RuntimeStructData<T extends Object> = Omit<{
+    [K in keyof T as T[K] extends Function ? never : Capitalize<string & K>]?: T[K] | string;
+}, "Id">;
+export type SerialisedTSType<T = {}> = [
+    string,
+    T extends string | number | boolean | void | undefined ? T : T extends (infer J)[] ? (J extends {
+        __proto__: any;
+    } ? SerialisedType<J> : J)[] : T extends JSON ? T : T extends Object ? SerialisedType<T> : T
+];
+export declare const TypeSymbol: unique symbol;
+export declare const DataSymbol: unique symbol;
+export declare enum ClassCategory {
+    Primitive = 0,
+    Struct = 1,
+    Inlined = 2,
+    Pointer = 4,
+    Custom = 8
+}
+export declare namespace ClassCategory {
+    function isType(type: ClassCategory, category: ClassCategory): boolean;
+    function isTypeOr(type: ClassCategory, ...categories: ClassCategory[]): boolean;
+    function isTypeAnd(type: ClassCategory, ...categories: ClassCategory[]): boolean;
+}
+export declare enum PropertyTypes {
+    AsIs = 0,// No modifications
+    Definition = 1,// Storing the class' data instead of value.
+    Serialised = 2,// Storing the class' serialised data instead of value.
+    ForceInline = 3,// Turns a reference into a value when serialising.
+    Expression = 4,
+    Array = 8,
+    Array2 = 16,
+    Dictionary = 32,//Made with {}
+    Map = 64,//Made with the Map class
+    Solo = 128
+}
+export declare namespace PropertyTypes {
+    function isType(type: PropertyTypes, category: PropertyTypes): boolean;
+    function isTypeOr(type: PropertyTypes, ...categories: PropertyTypes[]): boolean;
+    function isTypeAnd(type: PropertyTypes, ...categories: PropertyTypes[]): boolean;
+    function ModOnly(type: PropertyTypes): number;
+    function allAreType(category: PropertyTypes, ...types: PropertyTypes[]): boolean;
+}
+export type Primitive = typeof String | typeof Number | typeof Boolean | null | undefined;
+export declare function isPrimitiveType(type: any): type is Primitive;
+export declare function primitiveTypeName(type: any): string;
+export declare function GetTypeName(type: Primitive | ReplicableClass): string;
+export declare function isPrimitiveValue(object: any): boolean;
+export declare function getPrimitiveClass(object: any): NumberConstructor | StringConstructor | BooleanConstructor | null | undefined;
+export declare function ValueIsPrimitiveType(type: Primitive, value: any): boolean;