@bikky/replication 1.0.1

package/Transformers/SchemaGenerator.d.ts

@@ -0,0 +1,102 @@
+import { SetMap, SmartArray } from "@bikky/smart-collections";
+import { Primitive } from "../Constants/SerialisationTypes.js";
+import { ReplicableClass } from "../Tracking/Class.js";
+import { ComplexPropertyType, PropertyConfiguration, PropertyLoadingTypeInfo } from "../Tracking/Property.js";
+import { Versions } from "../Constants/Versions.js";
+export declare namespace GeneratorUtilities {
+    const ReplRoot: any;
+    const ExpressionString = "`@{${string}}`";
+    const SerialisedExpressionString = "[ \"Expression\", string ]";
+    const GenerationForward = "// This file is automatically generated. Do not edit it, all edits will be overwritten on compile.";
+    const DefinitionForward: string;
+    interface CustomTypes {
+        ts: {
+            name: string;
+            DefinitionType: string | any[] | ComplexPropertyType[];
+            op: "&" | "|";
+            append?: string;
+        }[];
+        ser: {
+            name: string;
+            DefinitionType: string | any[] | ComplexPropertyType[];
+            op: "&" | "|";
+            append?: string;
+        }[];
+        def: {
+            name: string;
+            DefinitionType: string | any[] | ComplexPropertyType[];
+            op: "&" | "|";
+            append?: string;
+        }[];
+    }
+    function SortTypes(a: string | ReplicableClass | Primitive, b: string | ReplicableClass | Primitive): 1 | 0 | -1;
+    function SortLoadingInfo(a: PropertyLoadingTypeInfo, b: PropertyLoadingTypeInfo): 1 | 0 | -1;
+    function SortTypeContainers(a: string | {
+        type: ReplicableClass | Primitive;
+    }, b: string | {
+        type: ReplicableClass | Primitive;
+    }): 1 | 0 | -1;
+    function ToProjectPath(path: string): string;
+    function CalcProjectPath(rel: string | undefined, base: string): string;
+    function GenerateInterfaceFilepathForFile(file: string): string;
+    function GenerateAPIName(dataType: ReplicableClass | Primitive, style: "creation" | "definition" | "serialised" | "typescript", referencable: boolean): string;
+    interface GenerationDetails {
+        blocks: string[];
+        includes: SetMap<string, string>;
+    }
+    /**
+     * Generates the scheme for the value of a property ignoring modifiers like array, map and dict.
+     *
+     * Produces the quoted part of the following definitions:
+     *   val: {[xx]: `(TypeA | TypeB | Expression)` } | Expression;
+     *   val: `TypeA | TypeB | Expression`;
+     *   val: `(TypeA | TypeB | Expression)`[] | Expression;
+     *
+     * Produces the back quoted part of the following serialised types:
+     *   ser: [ "Dict", {[xx]: `[ "Primitive", TypeA | TypeB ]` } ] | [ "Expression", string ];
+     *	 ser: `[ "Primitive", TypeA | TypeB ] | [ "Expression", string ]`; <-- note expression included here.
+     *	 ser: [ "Array", `[ "Primitive", TypeA | TypeB ]` ] | [ "Expression", string ];
+     *
+     * @param className The name of the parent class of the property.
+     * @param types The property definition.
+     * @param gen The generation details which includes are added to.
+     * @param style Whether we're generating creation types, definition types or serialised types.
+     */
+    function GenerateValueGroup(className: string, types: (ReplicableClass | Primitive)[], gen: GenerationDetails, forceInline: boolean | undefined, style: "creation" | "definition" | "serialised" | "typescript"): any;
+    function GenerateProperty(className: string, conf: PropertyConfiguration, gen: GenerationDetails, style: "creation" | "definition" | "serialised" | "typescript"): GenerationDetails;
+    function GenerateClassExtends(type: ReplicableClass, includes: SetMap<string, string>, style: "creation" | "definition" | "serialised"): string;
+    function GenerateClass(classType: ReplicableClass, gen: GenerationDetails, style: "creation" | "definition" | "serialised"): GenerationDetails;
+    function GenerateClassWithCustomDef(classType: ReplicableClass, gen: GenerationDetails, style: "definition" | "serialised"): GenerationDetails | undefined;
+    function GenerateCustomType(types: CustomTypes, gen: GenerationDetails, style: "definition" | "serialised" | "typescript"): void;
+    function GenerateImports(file: string, includes: SetMap<string, string>): string;
+    function GenerateDefinitionFile(file: string, repls: ReplicableClass[] | undefined, types: CustomTypes | undefined): string;
+    function GenerateTypescriptFile(includeFiles: SmartArray<any>, file: string): string;
+}
+export declare namespace SchemaGenerator {
+    function RegisterCustomTsInclude(type: {
+        name: string;
+        DefinitionType: any[];
+    }): void;
+    function RegisterCustomTsType(type: {
+        name: string;
+        DefinitionType: any[];
+        op: "&" | "|";
+        append?: string;
+    }): void;
+    function RegisterCustomSerialisedType(type: {
+        name: string;
+        DefinitionType: any[];
+        op: "&" | "|";
+        append?: string;
+    }): void;
+    function RegisterCustomDefinitionType(type: {
+        name: string;
+        DefinitionType: any[];
+        op: "&" | "|";
+        append?: string;
+    }): void;
+    function GenerateAllInterfaceTypes(version: string | Versions, options: {
+        open(file: string): boolean;
+        write(file: string, text: string): boolean;
+    }): void;
+}

package/Transformers/SchemaGenerator.js

@@ -0,0 +1,564 @@
+import { BikPath } from "@bikky/path";
+import { ArrayMap, SetMap } from "@bikky/smart-collections";
+import { ClassCategory, describeObject, isPrimitiveType, primitiveTypeName, PropertyTypes } from "../Constants/SerialisationTypes.js";
+import { ReplicableRegistry } from "../Constants/ReplicableRegistry.js";
+import { ReplicableClass } from "../Tracking/Class.js";
+import { FormatPropInput } from "../Tracking/Property.js";
+import { Versions } from "../Constants/Versions.js";
+import { Expression } from "../Expressions/Expression.js";
+var getCurrentFilepath = BikPath.getCurrentFilepath;
+export var GeneratorUtilities;
+(function (GeneratorUtilities) {
+    GeneratorUtilities.ReplRoot = BikPath.join(getCurrentFilepath(), "../../../../../");
+    GeneratorUtilities.ExpressionString = "`@{${string}}`";
+    GeneratorUtilities.SerialisedExpressionString = `[ "Expression", string ]`;
+    GeneratorUtilities.GenerationForward = "// This file is automatically generated. Do not edit it, all edits will be overwritten on compile.";
+    GeneratorUtilities.DefinitionForward = GeneratorUtilities.GenerationForward + `
+// This file contains the typescript types for the data definitions for the corresponding 
+// types in the .ts file this file is named after.
+	`.trim();
+    function SortTypes(a, b) {
+        let aName = a instanceof ReplicableClass ? a.opts.typescriptTypeName
+            : isPrimitiveType(a) ? primitiveTypeName(a) : a;
+        let bName = b instanceof ReplicableClass ? b.opts.typescriptTypeName
+            : isPrimitiveType(b) ? primitiveTypeName(b) : b;
+        return aName == bName ? 0 : aName < bName ? -1 : 1;
+    }
+    GeneratorUtilities.SortTypes = SortTypes;
+    function SortLoadingInfo(a, b) {
+        return a.sortIndex < b.sortIndex ? -1 : a.sortIndex > b.sortIndex ? 1 : 0;
+    }
+    GeneratorUtilities.SortLoadingInfo = SortLoadingInfo;
+    function SortTypeContainers(a, b) {
+        return SortTypes(typeof a === "string" ? a : a.type, typeof b === "string" ? b : b.type);
+    }
+    GeneratorUtilities.SortTypeContainers = SortTypeContainers;
+    function ToProjectPath(path) {
+        return path.replace(GeneratorUtilities.ReplRoot, "/");
+    }
+    GeneratorUtilities.ToProjectPath = ToProjectPath;
+    function CalcProjectPath(rel, base) {
+        return rel ? ToProjectPath(BikPath.join(base, rel)) : ToProjectPath(base);
+    }
+    GeneratorUtilities.CalcProjectPath = CalcProjectPath;
+    function GenerateInterfaceFilepathForFile(file) {
+        return file.replace(/\.[jt]s/, ".data.d.ts");
+    }
+    GeneratorUtilities.GenerateInterfaceFilepathForFile = GenerateInterfaceFilepathForFile;
+    function GenerateAPIName(dataType, style, referencable) {
+        if (isPrimitiveType(dataType)) {
+            return primitiveTypeName(dataType);
+        }
+        let dataTypeName = dataType.opts.dataTypeName;
+        return style === "typescript" ? dataTypeName : style === "creation" ? dataTypeName :
+            style === "definition" ? dataTypeName + "Definition" :
+                referencable ? dataTypeName + "SerialisedReference" :
+                    dataTypeName + "Serialised";
+    }
+    GeneratorUtilities.GenerateAPIName = GenerateAPIName;
+    /**
+     * Generates the scheme for the value of a property ignoring modifiers like array, map and dict.
+     *
+     * Produces the quoted part of the following definitions:
+     *   val: {[xx]: `(TypeA | TypeB | Expression)` } | Expression;
+     *   val: `TypeA | TypeB | Expression`;
+     *   val: `(TypeA | TypeB | Expression)`[] | Expression;
+     *
+     * Produces the back quoted part of the following serialised types:
+     *   ser: [ "Dict", {[xx]: `[ "Primitive", TypeA | TypeB ]` } ] | [ "Expression", string ];
+     *	 ser: `[ "Primitive", TypeA | TypeB ] | [ "Expression", string ]`; <-- note expression included here.
+     *	 ser: [ "Array", `[ "Primitive", TypeA | TypeB ]` ] | [ "Expression", string ];
+     *
+     * @param className The name of the parent class of the property.
+     * @param types The property definition.
+     * @param gen The generation details which includes are added to.
+     * @param style Whether we're generating creation types, definition types or serialised types.
+     */
+    function GenerateValueGroup(className, types, gen, forceInline = false, style) {
+        let sortedTypes = types.toSorted(SortTypes);
+        let primTypes = [];
+        let value = sortedTypes.map((type) => {
+            if (style === "serialised") {
+                if (isPrimitiveType(type)) {
+                    primTypes.push(primitiveTypeName(type));
+                    return undefined;
+                }
+                else if (ClassCategory.isType(type.category, ClassCategory.Pointer) && !forceInline) {
+                    return GenerateAPIName(type, style, true);
+                }
+                else if (ClassCategory.isType(type.category, ClassCategory.Custom)) {
+                    if (ClassCategory.isType(type.category, ClassCategory.Pointer) && !forceInline) {
+                        return `[ "${type.opts.dataTypeName}" | string, ${GenerateAPIName(type, style, false)} | null ]`;
+                    }
+                    return `[ "${type.opts.dataTypeName}", ${GenerateAPIName(type, style, false)} ]`;
+                }
+                else {
+                    return `[ "${type.opts.dataTypeName}" | string, ${GenerateAPIName(type, style, false)} | null ]`;
+                }
+            }
+            if (style === "creation" && type instanceof ReplicableClass) {
+                return GenerateAPIName(type, style, false) + " | " + GenerateAPIName(type, "definition", true);
+            }
+            if (style === "typescript" && type instanceof ReplicableClass) {
+                return GenerateAPIName(type, style, false);
+            }
+            return GenerateAPIName(type, style, false);
+        }).sort().filter((e) => e).join(" | ");
+        if (primTypes.length > 0) {
+            let separator = value.trim().length > 0 ? " | " : "";
+            if (style === "serialised") {
+                value = `[ "Primitive", ${primTypes.sort().join(" | ")} ]` + separator + value;
+            }
+            else {
+                value = primTypes.sort().join(" | ") + separator + value;
+            }
+        }
+        //Add required imports.
+        for (let type of sortedTypes) {
+            if (type instanceof ReplicableClass) {
+                if (style === "typescript") {
+                    gen.includes.push(CalcProjectPath(undefined, type.opts.file), GenerateAPIName(type, style, true));
+                }
+                else if (style === "creation") {
+                    gen.includes.push(GenerateInterfaceFilepathForFile(CalcProjectPath(undefined, type.opts.file)), GenerateAPIName(type, "definition", true));
+                    gen.includes.push(CalcProjectPath(undefined, type.opts.file), GenerateAPIName(type, style, true));
+                }
+                else {
+                    let useReference = ClassCategory.isType(type.category, ClassCategory.Pointer) && !forceInline;
+                    gen.includes.push(GenerateInterfaceFilepathForFile(CalcProjectPath(undefined, type.opts.file)), GenerateAPIName(type, style, useReference));
+                }
+            }
+        }
+        return value;
+    }
+    GeneratorUtilities.GenerateValueGroup = GenerateValueGroup;
+    function GenerateProperty(className, conf, gen, style) {
+        var _a, _b, _c, _d;
+        let selection = style !== "serialised" ? conf.load : conf.serialisation;
+        let fullValue = "";
+        let name = style === "serialised" ? conf.name : conf.load.name;
+        for (let def of selection.types) {
+            if (!Array.isArray(def.types)) {
+                if (fullValue.length > 0)
+                    fullValue += " | ";
+                fullValue += selection.types;
+                continue;
+            }
+            let value = GeneratorUtilities.GenerateValueGroup(className, def.types, gen, PropertyTypes.isType(def.modifiers, PropertyTypes.ForceInline), style);
+            if (conf.expressionForProperty && PropertyTypes.ModOnly(def.modifiers) !== PropertyTypes.Solo) {
+                if (style !== "serialised") {
+                    value += " | " + GeneratorUtilities.ExpressionString;
+                }
+                else {
+                    value += ` | ` + GeneratorUtilities.SerialisedExpressionString;
+                }
+            }
+            if (!PropertyTypes.isType(def.modifiers, PropertyTypes.Solo)) {
+                if (style === "serialised") {
+                    if (value.includes("] | [")) {
+                        value = "(" + value + ")";
+                    }
+                }
+                else {
+                    if (value.includes(" | ")) {
+                        value = "(" + value + ")";
+                    }
+                }
+            }
+            //Map and Dict
+            if (PropertyTypes.isTypeOr(def.modifiers, PropertyTypes.Map, PropertyTypes.Dictionary)) {
+                /*
+                 * Creation: Map or Dict. (needs both)
+                 * Definition: Map or Dict. (needs both)
+                 * Serialised: Dict typing as map or dict name. (needs both)
+                 * Typescript: Map or Dict. (needs both)
+                 */
+                let text;
+                let mapText;
+                if (def.restrictedTo) {
+                    text = `{[key in ${def.restrictedTo.map((e) => typeof e === "string" ? `"${e}"` : e).join(" | ")}]: ${value}}`;
+                    mapText = `Map<${def.restrictedTo.map((e) => typeof e === "string" ? `"${e}"` : e).join(" | ")}, ${value}>`;
+                }
+                else {
+                    text = `{[key: ${def.keyType.includes(Expression) ? "string" : (_b = (_a = def.keyType) === null || _a === void 0 ? void 0 : _a.map((e) => primitiveTypeName(e)).join(" | ")) !== null && _b !== void 0 ? _b : "string"}]: ${value}}`;
+                    mapText = `Map<${def.keyType.includes(Expression) ? "string" : (_d = (_c = def.keyType) === null || _c === void 0 ? void 0 : _c.map((e) => primitiveTypeName(e)).join(" | ")) !== null && _d !== void 0 ? _d : "string"}, ${value}>`;
+                }
+                let isMap = PropertyTypes.isType(def.modifiers, PropertyTypes.Map);
+                value = style !== "serialised" ? text : (isMap ? `[ "Map", ${text} ]` : `[ "Dict", ${text} ]`);
+                if (isMap && style === "creation") {
+                    //No expressions allowed in the fancy values.
+                    value += ` | ` + mapText.replace(" | " + GeneratorUtilities.ExpressionString, "");
+                }
+            }
+            //Array 2
+            else if (PropertyTypes.isType(def.modifiers, PropertyTypes.Array2)) {
+                value = style !== "serialised" ? `${value}[][]` : `[ "Array2", ${value}[][] ]`;
+            }
+            //Array 1
+            else if (PropertyTypes.isType(def.modifiers, PropertyTypes.Array)) {
+                value = style !== "serialised" ? `${value}[]` : `[ "Array", ${value}[] ]`;
+            }
+            fullValue += (fullValue.length > 0 ? " | " : "") + value;
+        }
+        if (conf.expressionForProperty) {
+            if (style !== "serialised") {
+                fullValue += " | " + GeneratorUtilities.ExpressionString;
+            }
+            else {
+                fullValue += ` | ` + GeneratorUtilities.SerialisedExpressionString;
+            }
+        }
+        if (style !== "serialised" && conf.load.present === "optional") {
+            name += "?";
+        }
+        gen.blocks.push(`\t${name}: ${fullValue};`);
+        return gen;
+    }
+    GeneratorUtilities.GenerateProperty = GenerateProperty;
+    function GenerateClassExtends(type, includes, style) {
+        let text = "";
+        let postfix = style === "creation" ? "Creation" : "";
+        if (type.parents.length > 0) {
+            let parents = [...type.parents].sort(SortTypes);
+            if (style === "definition") {
+                text += `extends ${parents.map((e) => `Omit<${GenerateAPIName(e, style, false) + postfix}, "Class">`).join(", ")} `;
+            }
+            else {
+                text += `extends ${parents.map((e) => `${GenerateAPIName(e, style, false) + postfix}`).join(", ")} `;
+            }
+            for (let parent of parents) {
+                if (isPrimitiveType(parent.classConstructor))
+                    continue;
+                includes.push(GenerateInterfaceFilepathForFile(CalcProjectPath(undefined, parent.opts.file)), GenerateAPIName(parent, style, false) + postfix);
+            }
+        }
+        return text;
+    }
+    GeneratorUtilities.GenerateClassExtends = GenerateClassExtends;
+    function GenerateClass(classType, gen, style) {
+        let props = classType.finalised_ownPropertyNames.toSorted();
+        let propGen = {
+            blocks: [],
+            includes: gen.includes
+        };
+        if (style === "definition") {
+            propGen.blocks.push(`\tClass: "${classType.opts.dataTypeName}";`);
+        }
+        else if (style === "serialised") {
+            propGen.blocks.push(`\tversion: string;`);
+        }
+        for (let propName of classType.finalised_ownPropertyNames) {
+            let def = classType.getPropDefinition(Versions.MAX, propName);
+            if ("removed" in def || "doesntExist" in def)
+                continue;
+            if (style !== "serialised" && def.load.present == false)
+                continue;
+            if (style === "serialised" && def.serialisation.present == false)
+                continue;
+            GeneratorUtilities.GenerateProperty(classType.opts.dataTypeName, def, propGen, style);
+        }
+        gen.blocks.sort();
+        let name = GeneratorUtilities.GenerateAPIName(classType, style, false) + (style === "creation" ? "Creation" : "");
+        gen.blocks.push(`export interface ${name} ${GenerateClassExtends(classType, gen.includes, style)}{`
+            + `\n${propGen.blocks.join("\n")}`
+            + `\n}`);
+        if (style === "serialised") {
+            if (ClassCategory.isType(classType.category, ClassCategory.Pointer)) {
+                gen.blocks.push(`export type ${GeneratorUtilities.GenerateAPIName(classType, style, false)}Reference = [ string, ...(string | number)[] ];`);
+            }
+            else {
+                gen.blocks.push(`export type ${GeneratorUtilities.GenerateAPIName(classType, style, false)}Reference = [ string, ${GeneratorUtilities.GenerateAPIName(classType, style, false)} ];`);
+            }
+        }
+        return gen;
+    }
+    GeneratorUtilities.GenerateClass = GenerateClass;
+    function GenerateClassWithCustomDef(classType, gen, style) {
+        if (!("DefinitionType" in classType.classConstructor)) {
+            throw new Error(`Failed to find DefinitionType for ${classType.opts.dataTypeName}`);
+        }
+        let def;
+        if (typeof classType.classConstructor.DefinitionType === "string") {
+            def = classType.classConstructor.DefinitionType;
+        }
+        else {
+            def = FormatPropInput(classType.classConstructor.DefinitionType);
+        }
+        if (style === "serialised" && "SerialisedType" in classType.classConstructor) {
+            if (typeof classType.classConstructor.SerialisedType === "string") {
+                def = classType.classConstructor.SerialisedType;
+            }
+            else {
+                def = FormatPropInput(classType.classConstructor.DefinitionType);
+            }
+        }
+        if (typeof def === "string") {
+            if (style === "definition") {
+                gen.blocks.push(`export type ${GenerateAPIName(classType, "definition", false)} = ${def};`);
+            }
+            else {
+                gen.blocks.push(`export type ${GenerateAPIName(classType, "serialised", false)} = ${def};`);
+                gen.blocks.push(`export type ${GenerateAPIName(classType, "serialised", false)}Reference = [ string, ${GenerateAPIName(classType, "serialised", false)} ];`);
+            }
+            return;
+        }
+        let valGen = {
+            blocks: [],
+            includes: gen.includes
+        };
+        let possibleModifiers = PropertyTypes.AsIs;
+        let refinedDefs = def.map((e) => {
+            let modifiers = "array" in e ? e.array == 2 ? PropertyTypes.Array2 : PropertyTypes.Array :
+                "mapKey" in e ? PropertyTypes.Map : "dictKey" in e ? PropertyTypes.Dictionary : PropertyTypes.Solo;
+            let key = "mapKey" in e ? e.mapKey : "dictKey" in e ? e.dictKey : undefined;
+            possibleModifiers |= modifiers;
+            e.type = e.type.flatMap((e) => {
+                if (isPrimitiveType(e))
+                    return e;
+                if (!(e instanceof ReplicableClass)) {
+                    let types = ReplicableRegistry.__GetReplicablesFor(e);
+                    return types ? types : e;
+                }
+                return e;
+            });
+            return Object.assign(Object.assign({ types: e.type, modifiers, sortIndex: e.type.map((e) => isPrimitiveType(e) ? primitiveTypeName(e) : e.opts.dataTypeName).join(" | ") }, ("restrictedTo" in e ? { restrictedTo: e.restrictedTo } : {})), (key ? { keyType: Array.isArray(key) ? key : [key] } : {}));
+        });
+        GenerateProperty(classType.opts.dataTypeName, {
+            name: classType.opts.dataTypeName,
+            load: { name: classType.opts.dataTypeName, skipLoad: false, present: true, default: undefined, possibleModifiers, types: refinedDefs },
+            serialisation: { present: true, inline: true, possibleModifiers, types: refinedDefs },
+            expressionForProperty: undefined,
+            expressionForValue: undefined,
+            expressionForKey: undefined
+        }, valGen, style);
+        valGen.blocks[0] = valGen.blocks[0].replace(/^\t\w*: ?/, "");
+        if (style === "definition") {
+            gen.blocks.push(`export type ${GenerateAPIName(classType, "definition", false)} = ${valGen.blocks[0]}`);
+        }
+        else {
+            gen.blocks.push(`export type ${GenerateAPIName(classType, "serialised", false)} = ${valGen.blocks[0]}`);
+            gen.blocks.push(`export type ${GenerateAPIName(classType, "serialised", false)}Reference = [ string, ${GenerateAPIName(classType, "serialised", false)} ];`);
+        }
+        return gen;
+    }
+    GeneratorUtilities.GenerateClassWithCustomDef = GenerateClassWithCustomDef;
+    function GenerateCustomType(types, gen, style) {
+        let styleSpecifier = style === "definition" ? "Definition" : style === "serialised" ? "Serialised" : "";
+        let details = style === "definition" ? types.def : style === "serialised" ? types.ser : types.ts;
+        for (let config of details) {
+            let values = "";
+            let def = FormatPropInput(config.DefinitionType);
+            let possibleModifiers = PropertyTypes.AsIs;
+            let refinedDefs = def.map((e) => {
+                let modifiers = "array" in e ? e.array == 2 ? PropertyTypes.Array2 : PropertyTypes.Array :
+                    "mapKey" in e ? PropertyTypes.Map : "dictKey" in e ? PropertyTypes.Dictionary : PropertyTypes.Solo;
+                let key = "mapKey" in e ? e.mapKey : "dictKey" in e ? e.dictKey : undefined;
+                possibleModifiers |= modifiers;
+                e.type = e.type.flatMap((e) => {
+                    if (isPrimitiveType(e))
+                        return e;
+                    if (!(e instanceof ReplicableClass)) {
+                        let types = ReplicableRegistry.__GetReplicablesFor(e);
+                        return types ? types : e;
+                    }
+                    return e;
+                });
+                return Object.assign(Object.assign({ types: e.type, modifiers, sortIndex: e.type.map((e) => {
+                        if (isPrimitiveType(e)) {
+                            return primitiveTypeName(e);
+                        }
+                        return e.opts.dataTypeName;
+                    }).join(" | ") }, ("restrictedTo" in e ? { restrictedTo: e.restrictedTo } : {})), (key ? { keyType: Array.isArray(key) ? key : [key] } : {}));
+            });
+            let valGen = {
+                blocks: [],
+                includes: gen.includes
+            };
+            GenerateProperty(config.name, {
+                name: config.name,
+                load: { name: config.name, skipLoad: false, present: true, default: undefined, possibleModifiers, types: refinedDefs },
+                serialisation: { present: true, inline: true, possibleModifiers, types: refinedDefs },
+                expressionForProperty: undefined,
+                expressionForValue: undefined,
+                expressionForKey: undefined
+            }, valGen, style);
+            for (let block of valGen.blocks) {
+                if (values.length > 0)
+                    values += " " + config.op + " ";
+                block = block.replace(/ \| `@\{\$\{string}}`(;?)$/, "$1");
+                if (style === "serialised") {
+                    block = block.replace(/ \| \[ "Expression", string ](;?)$/, "$1");
+                    block = block.replace(/\[ "\w*", (\w*) ]/g, "$1");
+                }
+                if (config.op === "&") {
+                    block = block.replace(/\|/g, "&");
+                }
+                values += block.replace(`\t${config.name}: `, "").replace(";", "");
+            }
+            gen.blocks.push(`export type ${config.name}${styleSpecifier} = ${values}${config.append ? " " + config.append : ""};`);
+            if (style === "serialised") {
+                gen.blocks.push("export type " + config.name + "SerialisedReference = [ " + config.name + " | string, " + config.name + "Serialised ];");
+            }
+        }
+    }
+    GeneratorUtilities.GenerateCustomType = GenerateCustomType;
+    function GenerateImports(file, includes) {
+        let start = CalcProjectPath(undefined, BikPath.dir(file));
+        let paths = Array.from(includes.keys()).sort();
+        let header = "";
+        for (let path of paths) {
+            let imports = Array.from(includes.get(path).values()).sort();
+            if (/^\/\\/.test(path)) {
+                path = BikPath.join(GeneratorUtilities.ReplRoot, path);
+            }
+            let from = BikPath.importable(BikPath.getRelativePathTo(start, path));
+            if (from === "./" + BikPath.file(file)) {
+                continue;
+            }
+            from = from.replace(/(?:\.d)?\.ts$/, ".js");
+            header += `import { ` + imports.join(", ") + ` } from "${from}";\n`;
+        }
+        return header;
+    }
+    GeneratorUtilities.GenerateImports = GenerateImports;
+    function GenerateDefinitionFile(file, repls, types) {
+        let includes = new SetMap();
+        let tsGen = {
+            blocks: [],
+            includes: includes
+        };
+        let topGen = {
+            blocks: [],
+            includes: includes
+        };
+        let middleGen = {
+            blocks: [],
+            includes: includes
+        };
+        let bottomGen = {
+            blocks: [],
+            includes: includes
+        };
+        if (types) {
+            GeneratorUtilities.GenerateCustomType(types, tsGen, "typescript");
+            GeneratorUtilities.GenerateCustomType(types, topGen, "definition");
+            GeneratorUtilities.GenerateCustomType(types, middleGen, "serialised");
+        }
+        if (repls) {
+            for (let repl of repls) {
+                if ("DefinitionType" in repl.classConstructor) {
+                    GeneratorUtilities.GenerateClassWithCustomDef(repl, topGen, "definition");
+                    GeneratorUtilities.GenerateClassWithCustomDef(repl, middleGen, "serialised");
+                }
+                else {
+                    GeneratorUtilities.GenerateClass(repl, topGen, "definition");
+                    GeneratorUtilities.GenerateClass(repl, middleGen, "serialised");
+                    GeneratorUtilities.GenerateClass(repl, bottomGen, "creation");
+                }
+            }
+        }
+        if (repls && repls.length > 0) {
+            //Delete the current file from the list of includes.
+            let outputFilepath = GenerateInterfaceFilepathForFile(file);
+            includes.delete(outputFilepath);
+        }
+        return GeneratorUtilities.GenerateImports(file, topGen.includes) + "\n\n\n"
+            + GeneratorUtilities.DefinitionForward + "\n\n\n"
+            + (tsGen.blocks.length > 0 ? tsGen.blocks.join("\n\n") + "\n\n\n\n" : "")
+            + topGen.blocks.join("\n\n") + "\n\n\n\n"
+            + middleGen.blocks.join("\n\n") + "\n\n\n\n"
+            + bottomGen.blocks.join("\n\n");
+    }
+    GeneratorUtilities.GenerateDefinitionFile = GenerateDefinitionFile;
+    function GetReplTypesForArray(propTypes, from) {
+        return propTypes.flatMap((e) => {
+            if (typeof e !== "string" && isPrimitiveType(e) || e === Object)
+                return e;
+            let result = ReplicableRegistry.__GetReplicablesFor(e);
+            if (!result) {
+                throw new Error(`Failed to find type ${describeObject(e)} for imports.`
+                    + ` Did you forget the @Type or @Struct decorator? \nFound in ${from.replace(".js", ".ts")}`);
+            }
+            return result;
+        });
+    }
+    function GenerateTypescriptFile(includeFiles, file) {
+        let types = GetReplTypesForArray(includeFiles.flat(), file);
+        let str = "";
+        for (let type of types) {
+            if (isPrimitiveType(type))
+                continue;
+            str += `import "${BikPath.getRelativePathTo(file, type.opts.file)}";\n`;
+        }
+        return GeneratorUtilities.GenerationForward + "\n\n" + str;
+    }
+    GeneratorUtilities.GenerateTypescriptFile = GenerateTypescriptFile;
+})(GeneratorUtilities || (GeneratorUtilities = {}));
+export var SchemaGenerator;
+(function (SchemaGenerator) {
+    const CustomTypesByFile = new Map();
+    const IncludeFiles = new ArrayMap();
+    function RegisterCustomTsInclude(type) {
+        let callerPath = BikPath.normalise(BikPath.getCallerFilepath());
+        let includePath = callerPath.replace(/\.[jt]s/, ".includes.ts");
+        IncludeFiles.push(includePath, type.DefinitionType);
+    }
+    SchemaGenerator.RegisterCustomTsInclude = RegisterCustomTsInclude;
+    function RegisterCustomTsType(type) {
+        let callerPath = BikPath.normalise(BikPath.getCallerFilepath());
+        let path = GeneratorUtilities.GenerateInterfaceFilepathForFile(callerPath);
+        let val = CustomTypesByFile.get(path);
+        if (!val)
+            CustomTypesByFile.set(path, val = { ts: [], ser: [], def: [] });
+        val.ts.push(type);
+    }
+    SchemaGenerator.RegisterCustomTsType = RegisterCustomTsType;
+    function RegisterCustomSerialisedType(type) {
+        let path = GeneratorUtilities.GenerateInterfaceFilepathForFile(BikPath.normalise(BikPath.getCallerFilepath()));
+        let val = CustomTypesByFile.get(path);
+        if (!val)
+            CustomTypesByFile.set(path, val = { ts: [], ser: [], def: [] });
+        val.ser.push(type);
+    }
+    SchemaGenerator.RegisterCustomSerialisedType = RegisterCustomSerialisedType;
+    function RegisterCustomDefinitionType(type) {
+        let path = GeneratorUtilities.GenerateInterfaceFilepathForFile(BikPath.normalise(BikPath.getCallerFilepath()));
+        let val = CustomTypesByFile.get(path);
+        if (!val)
+            CustomTypesByFile.set(path, val = { ts: [], ser: [], def: [] });
+        val.def.push(type);
+    }
+    SchemaGenerator.RegisterCustomDefinitionType = RegisterCustomDefinitionType;
+    function GenerateAllInterfaceTypes(version, options) {
+        let types = ReplicableRegistry.__GetAllReplicables();
+        let files = new SetMap();
+        for (let type of types) {
+            files.push(GeneratorUtilities.GenerateInterfaceFilepathForFile(type.opts.file), type);
+        }
+        for (let file of files.keys()) {
+            let types = [...files.get(file)].sort(GeneratorUtilities.SortTypes);
+            if (types.length < 1)
+                continue;
+            file = BikPath.normalise(file);
+            let str = GeneratorUtilities.GenerateDefinitionFile(file, types, CustomTypesByFile.get(file));
+            CustomTypesByFile.delete(file);
+            options.open(file);
+            options.write(file, str);
+        }
+        for (let [file, types] of CustomTypesByFile.entries()) {
+            file = BikPath.normalise(file);
+            let str = GeneratorUtilities.GenerateDefinitionFile(file, undefined, CustomTypesByFile.get(file));
+            options.open(file);
+            options.write(file, str);
+        }
+        /**
+         * Generate a file that you can import to import a bunch of other files.
+         */
+        for (let [file, startTypes] of IncludeFiles) {
+            let str = GeneratorUtilities.GenerateTypescriptFile(startTypes, file);
+            options.open(file);
+            options.write(file, str);
+        }
+    }
+    SchemaGenerator.GenerateAllInterfaceTypes = GenerateAllInterfaceTypes;
+})(SchemaGenerator || (SchemaGenerator = {}));