xml-model 0.1.0 → 0.2.0

package/build/module/defaults/index.d.ts

@@ -1,13 +1,14 @@
-import { PropDecoratorOptions, TagnameFromPropertyResolver } from "../model";
-import type { InstantiateHandler } from "../model";
-import { ClassType } from "../types";
-declare type defaults = {
-    instantiate: InstantiateHandler<unknown>;
-    tagnameFromClass: (ctx: {
-        class: ClassType;
-    }) => string;
-    tagnameFromProperty: TagnameFromPropertyResolver;
-    handleProperty: Required<PropDecoratorOptions>["handleProperty"];
+import type { XMLModelPropertyOptions } from "../model/types";
+import type { XMLModelOptions, XMLModel } from "../model/types";
+declare type defaults<T = any> = {
+    fromXML: Required<XMLModelOptions<T>>["fromXML"]["middlewares"][number];
+    propertySourceElementsFilter: XMLModelPropertyOptions<T>["isSourceElement"];
+    propertyResolveSourceElements: XMLModelPropertyOptions<T>["resolveElements"];
+    propertyFromXML: Required<XMLModelPropertyOptions<T>>["fromXML"];
+    toXML: Required<XMLModelOptions<T>>["toXML"]["middlewares"][number];
+    tagnameFromModel: (model: XMLModel) => string;
+    tagnameFromProperty: (property: XMLModelPropertyOptions<T>) => string;
+    propertyToXML: Required<XMLModelPropertyOptions<T>>["toXML"];
 };
 export declare const defaults: defaults;
 export {};

package/build/module/defaults/index.js

@@ -13,59 +13,152 @@ const __RΦ = { m: (k, v) => (t, ...a) => t && Reflect.metadata ? Reflect.metada
             __RΦ.t[id] = t = l;
         }
         return t;
-    }, t: { [833]: { RΦ: t => ({ TΦ: "&", t: [__RΦ.a(813), __RΦ.a(832)] }) }, [813]: { LΦ: t => LΦ_0.IΦXMLFromObjectPropHandlerContext }, [832]: { RΦ: t => ({ TΦ: "O", m: [{ n: "type", f: "", t: __RΦ.a(812) }] }) }, [812]: { LΦ: t => Object }, [22]: { RΦ: t => ({ TΦ: "V" }) }, [1044]: { RΦ: t => ({ TΦ: "&", t: [__RΦ.a(813), __RΦ.a(1043)] }) }, [1043]: { RΦ: t => ({ TΦ: "O", m: [{ n: "type", f: "", t: __RΦ.a(812) }] }) }, [4]: { RΦ: t => ({ TΦ: "~" }) } } };
-import { addElement as addXMLElement } from "../xml";
-import { findModel, } from "../model";
+    }, t: {} };
+import { getModel } from "../model";
 import kebabCase from "lodash/kebabCase";
-import * as LΦ_0 from "../model";
-function handleClassProperty(context) {
-    const propModel = findModel(context.type.class);
-    if (propModel) {
-        const el = propModel.toXMLElement(context.value);
-        if (context.tagname)
-            el.name = context.tagname;
-        addXMLElement(context.xml, el);
-    }
-}
-__RΦ.m("rt:p", [{ n: "context", t: () => __RΦ.a(833), v: null }])(handleClassProperty);
-__RΦ.m("rt:f", "F")(handleClassProperty);
-__RΦ.m("rt:t", () => __RΦ.a(22))(handleClassProperty);
-function handleClassArrayProperty(context) {
-    const elementModel = findModel(context.type.elementType.class);
-    if (elementModel) {
-        const xmlEl = {
-            type: "element",
-            elements: [],
-        };
-        context.value.forEach(__RΦ.f((arrayEl) => {
-            addXMLElement(xmlEl, elementModel.toXMLElement(arrayEl));
-        }, [__RΦ.m("rt:p", [{ n: "arrayEl", t: () => __RΦ.a(4), v: null }]), __RΦ.m("rt:f", "F>"), __RΦ.m("rt:t", () => __RΦ.a(22))], ""));
-        if (context.tagname)
-            xmlEl.name = context.tagname;
-        addXMLElement(context.xml, xmlEl);
-    }
-}
-__RΦ.m("rt:p", [{ n: "context", t: () => __RΦ.a(1044), v: null }])(handleClassArrayProperty);
-__RΦ.m("rt:f", "F")(handleClassArrayProperty);
-__RΦ.m("rt:t", () => __RΦ.a(22))(handleClassArrayProperty);
 export const defaults = {
-    instantiate() {
-        throw new Error("you should define defaults.instantiate yourself or provide an instantiate function to @Model() decorator's options");
+    fromXML() {
+        throw new TypeError("you should define 'defaults.fromXML' yourself or provide a 'fromXML' function to @Model() decorator's options");
     },
-    tagnameFromClass(ctx) {
-        return kebabCase(ctx.class.name);
+    propertyResolveSourceElements(context) {
+        // We assume context.xml.elements is a single tag containing all the props
+        // FIXME: is it safe ?
+        const innerElements = context.xml.elements[0]?.elements || [];
+        return innerElements.filter((el) => context.property.isSourceElement(el, context));
     },
-    tagnameFromProperty(context) {
-        return kebabCase(context.property);
+    propertySourceElementsFilter(element, context) {
+        return context.property.tagname === element.name;
     },
-    /* Handle Property */
-    handleProperty(context) {
-        const type = context.type;
+    propertyFromXML(context) {
+        // TODO: handle inline
+        const prop = context.property;
+        const elements = context.elements;
+        if (prop.model) {
+            return prop.model.fromXML({ elements });
+        }
+        const type = context.property.reflected.type;
+        if (prop.reflected.isOptional && elements.length === 0) {
+            return undefined;
+        }
         if (type.is("class")) {
-            handleClassProperty(context);
+            const model = getModel(type.class);
+            return model.fromXML({ elements: context.elements });
+        }
+        else if (type.is("array")) {
+            let arrayEl = {};
+            if (!prop.inline &&
+                elements.length === 1 &&
+                elements[0].name === prop.tagname) {
+                // we assume our array is contained in a root tag
+                arrayEl = elements[0];
+            }
+            else if (prop.inline) {
+                // we assume our array is contained in xml.elements
+                arrayEl = { elements };
+            }
+            const els = arrayEl.elements || [];
+            const elType = type.elementType;
+            if (elType.is("class")) {
+                const model = getModel(elType.class);
+                const xmlInstances = els.map((el) => ({
+                    elements: [el],
+                }));
+                return xmlInstances.map((xml) => model.fromXML(xml));
+            }
+        }
+        else if (type.is("union") &&
+            type.types.length &&
+            type.types[0].is("literal")) {
+            const firstType = type.types[0];
+            if (firstType.is("literal")) {
+                const firstTypeCtor = firstType.value.constructor;
+                if (type.types.every((type) => type.is("literal") && type.value.constructor === firstTypeCtor)) {
+                    // all elements of unions are litteral with same type
+                    const model = getModel(firstTypeCtor);
+                    return model.fromXML({ elements });
+                }
+            }
+        }
+        // TODO: should warn ???
+        return undefined;
+    },
+    /* Object -> XML */
+    toXML({ properties, model }) {
+        const elements = [];
+        model.resolveAllProperties().forEach((prop) => {
+            if (prop.name in properties && typeof prop.name !== "symbol") {
+                // FIXME: prop.name should never be a symbol anyway
+                const _xml = properties[prop.name];
+                _xml.elements.forEach((el) => {
+                    if (!prop.inline) {
+                        // overwrite tagnames
+                        el.name = prop.tagname; // TODO: configurable ?
+                    }
+                    elements.push(el);
+                });
+            }
+        });
+        return {
+            elements: [
+                {
+                    type: "element",
+                    name: model.options.tagname,
+                    elements,
+                },
+            ],
+        };
+    },
+    tagnameFromModel(model) {
+        return kebabCase(model.type.name);
+    },
+    tagnameFromProperty(property) {
+        return kebabCase(String(property.name));
+    },
+    propertyToXML(context) {
+        const property = context.property;
+        if (property.model) {
+            return property.model.toXML(context.value);
         }
-        else if (type.is("array") && type.elementType.is("class")) {
-            handleClassArrayProperty(context);
+        const type = property.reflected.type;
+        const value = context.value;
+        if (property.reflected.isOptional && typeof value === "undefined") {
+            return { elements: [] }; // FIXME should return unefined ???
         }
+        const getXML = () => {
+            if (type.is("class")) {
+                const model = getModel(type.class);
+                return model.toXML(value);
+            }
+            else if (type.is("array") && type.elementType.is("class")) {
+                const elementType = type.elementType;
+                if (elementType.is("class")) {
+                    const model = getModel(elementType.class);
+                    const elements = [];
+                    value.forEach((el) => elements.push(...model.toXML(el).elements));
+                    return { elements: [{ type: "element", name: "array", elements }] };
+                }
+                // TODO: handle other types of array
+            }
+            else if (type.is("union") &&
+                type.types.length &&
+                type.types[0].is("literal")) {
+                const firstType = type.types[0];
+                if (firstType.is("literal")) {
+                    const firstTypeCtor = firstType.value.constructor;
+                    if (type.types.every((type) => type.is("literal") && type.value.constructor === firstTypeCtor)) {
+                        // all elements of unions are litteral with same type
+                        const model = getModel(firstTypeCtor);
+                        return model.toXML(context.value);
+                    }
+                }
+            }
+            // TODO: should warn ???
+            return { elements: [] };
+        };
+        const xml = getXML();
+        if (context.property.inline)
+            return { elements: xml.elements.map((el) => el.elements || []).flat() };
+        else
+            return xml;
     },
 };

package/build/module/defaults/models.js

@@ -13,15 +13,46 @@ const __RΦ = { m: (k, v) => (t, ...a) => t && Reflect.metadata ? Reflect.metada
             __RΦ.t[id] = t = l;
         }
         return t;
-    }, t: { [4]: { RΦ: t => ({ TΦ: "~" }) }, [384]: { LΦ: t => LΦ_0.IΦElement }, [13]: { LΦ: t => String }, [14]: { LΦ: t => Number } } };
+    }, t: { [4]: { RΦ: t => ({ TΦ: "~" }) }, [103]: { RΦ: t => ({ TΦ: "O", m: [{ n: "elements", f: "", t: __RΦ.a(102) }] }) }, [102]: { RΦ: t => ({ TΦ: "[", e: __RΦ.a(101) }) }, [101]: { LΦ: t => LΦ_0.IΦElement }, [13]: { LΦ: t => String }, [14]: { LΦ: t => Number }, [1718]: { RΦ: t => ({ TΦ: "O", m: [{ n: "elements", f: "", t: __RΦ.a(3141) }] }) }, [3141]: { RΦ: t => ({ TΦ: "[", e: __RΦ.a(3139) }) }, [3139]: { RΦ: t => ({ TΦ: "O", m: [{ n: "type", f: "", t: __RΦ.a(13) }, { n: "name", f: "", t: __RΦ.a(13) }] }) }, [20]: { LΦ: t => Boolean } } };
 import { createModel } from "../model";
-import { getContent as getXMLContent, fromContent as xmlFromContent, } from "../xml";
+import { getContent, fromContent } from "../xml";
 import * as LΦ_0 from "xml-js/types";
+// string is <string>value</string>
 createModel(String, {
-    toXML: __RΦ.f((ctx) => (ctx.xml = xmlFromContent(ctx.object)), [__RΦ.m("rt:p", [{ n: "ctx", t: () => __RΦ.a(4), v: null }]), __RΦ.m("rt:f", "F>"), __RΦ.m("rt:t", () => __RΦ.a(384))], "toXML"),
-    instantiate: __RΦ.f((ctx) => String(getXMLContent(ctx.xml)), [__RΦ.m("rt:p", [{ n: "ctx", t: () => __RΦ.a(4), v: null }]), __RΦ.m("rt:f", "F>"), __RΦ.m("rt:t", () => __RΦ.a(13))], "instantiate"),
+    toXML: __RΦ.f((ctx) => {
+        return {
+            elements: [fromContent(ctx.object, "string")],
+        };
+    }, [__RΦ.m("rt:p", [{ n: "ctx", t: () => __RΦ.a(4), v: null }]), __RΦ.m("rt:f", "F>"), __RΦ.m("rt:t", () => __RΦ.a(103))], "toXML"),
+    fromXML: __RΦ.f((ctx) => {
+        return String(getContent(ctx.xml.elements[0]));
+    }, [__RΦ.m("rt:p", [{ n: "ctx", t: () => __RΦ.a(4), v: null }]), __RΦ.m("rt:f", "F>"), __RΦ.m("rt:t", () => __RΦ.a(13))], "fromXML"),
 });
+// number is <number>value</number>
 createModel(Number, {
-    toXML: __RΦ.f((ctx) => (ctx.xml = xmlFromContent(String(ctx.object))), [__RΦ.m("rt:p", [{ n: "ctx", t: () => __RΦ.a(4), v: null }]), __RΦ.m("rt:f", "F>"), __RΦ.m("rt:t", () => __RΦ.a(384))], "toXML"),
-    instantiate: __RΦ.f((ctx) => Number(getXMLContent(ctx.xml)), [__RΦ.m("rt:p", [{ n: "ctx", t: () => __RΦ.a(4), v: null }]), __RΦ.m("rt:f", "F>"), __RΦ.m("rt:t", () => __RΦ.a(14))], "instantiate"),
+    toXML: __RΦ.f((ctx) => {
+        return {
+            elements: [fromContent(String(ctx.object), "number")],
+        };
+    }, [__RΦ.m("rt:p", [{ n: "ctx", t: () => __RΦ.a(4), v: null }]), __RΦ.m("rt:f", "F>"), __RΦ.m("rt:t", () => __RΦ.a(103))], "toXML"),
+    fromXML: __RΦ.f((ctx) => {
+        return Number(getContent(ctx.xml.elements[0]));
+    }, [__RΦ.m("rt:p", [{ n: "ctx", t: () => __RΦ.a(4), v: null }]), __RΦ.m("rt:f", "F>"), __RΦ.m("rt:t", () => __RΦ.a(14))], "fromXML"),
+});
+// number is <boolean>value</boolean>
+createModel(Boolean, {
+    toXML: __RΦ.f((ctx) => {
+        return {
+            elements: [
+                {
+                    type: "element",
+                    name: "boolean",
+                    ...fromContent(String(ctx.object)),
+                },
+            ],
+        };
+    }, [__RΦ.m("rt:p", [{ n: "ctx", t: () => __RΦ.a(4), v: null }]), __RΦ.m("rt:f", "F>"), __RΦ.m("rt:t", () => __RΦ.a(1718))], "toXML"),
+    fromXML: __RΦ.f((ctx) => {
+        return Boolean(getContent(ctx.xml.elements[0]));
+    }, [__RΦ.m("rt:p", [{ n: "ctx", t: () => __RΦ.a(4), v: null }]), __RΦ.m("rt:f", "F>"), __RΦ.m("rt:t", () => __RΦ.a(20))], "fromXML"),
 });

package/build/module/errors.d.ts

@@ -1,3 +1,4 @@
-export declare class NoExplicitTypeError extends Error {
-    constructor(typeName: string, propertyKey: string, parameterIndex?: number, argName?: string);
+export declare class XMLConversionError extends Error {
+    origin: unknown;
+    constructor(message: string, origin?: XMLConversionError["origin"]);
 }

package/build/module/errors.js

@@ -13,25 +13,20 @@ const __RΦ = { m: (k, v) => (t, ...a) => t && Reflect.metadata ? Reflect.metada
             __RΦ.t[id] = t = l;
         }
         return t;
-    }, t: { [13]: { LΦ: t => String }, [14]: { LΦ: t => Number } } };
-export class NoExplicitTypeError extends Error {
-    constructor(typeName, propertyKey, parameterIndex, argName) {
-        let errorMessage = `Unable to infer XMLModel type from TypeScript reflection system. You need to provide explicit type for `;
-        if (argName) {
-            errorMessage += `argument named '${argName}' of `;
-        }
-        else if (parameterIndex !== undefined) {
-            errorMessage += `parameter #${parameterIndex} of `;
-        }
-        errorMessage += `'${propertyKey}' of '${typeName}' class.`;
-        super(errorMessage);
-        Object.setPrototypeOf(this, new.target.prototype);
+    }, t: { [13]: { LΦ: t => String }, [8]: { RΦ: t => ({ TΦ: "U" }) } } };
+export class XMLConversionError extends Error {
+    origin;
+    constructor(message, origin) {
+        super(message);
+        this.origin = origin;
     }
 }
-(t => __RΦ.t[85] = t)(NoExplicitTypeError);
-__RΦ.m("rt:SP", [])(NoExplicitTypeError);
-__RΦ.m("rt:P", [])(NoExplicitTypeError);
-__RΦ.m("rt:Sm", [])(NoExplicitTypeError);
-__RΦ.m("rt:m", [])(NoExplicitTypeError);
-__RΦ.m("rt:p", [{ n: "typeName", t: () => __RΦ.a(13), v: null }, { n: "propertyKey", t: () => __RΦ.a(13), v: null }, { n: "parameterIndex", t: () => __RΦ.a(14), v: null, f: "?" }, { n: "argName", t: () => __RΦ.a(13), v: null, f: "?" }])(NoExplicitTypeError);
-__RΦ.m("rt:f", "Ce")(NoExplicitTypeError);
+(t => __RΦ.t[85] = t)(XMLConversionError);
+__RΦ.m("rt:SP", [])(XMLConversionError);
+__RΦ.m("rt:P", ["origin"])(XMLConversionError);
+__RΦ.m("rt:Sm", [])(XMLConversionError);
+__RΦ.m("rt:m", [])(XMLConversionError);
+__RΦ.m("rt:p", [{ n: "message", t: () => __RΦ.a(13), v: null }, { n: "origin", t: () => __RΦ.a(8), v: null, f: "?" }])(XMLConversionError);
+__RΦ.m("rt:f", "Ce")(XMLConversionError);
+__RΦ.m("rt:t", () => __RΦ.a(8))(XMLConversionError.prototype, "origin");
+__RΦ.m("rt:f", "P")(XMLConversionError.prototype, "origin");

package/build/module/index.d.ts

@@ -1,4 +1,5 @@
-export type { XMLElement } from "./types";
+export type { XMLElement, XMLRoot, Constructor } from "./types";
+export { defaults } from "./defaults";
 export { getModel, createModel, Model, Prop } from "./model";
 import XML from "./xml";
 export { XML };

package/build/module/index.js

@@ -14,6 +14,7 @@ const __RΦ = { m: (k, v) => (t, ...a) => t && Reflect.metadata ? Reflect.metada
         }
         return t;
     }, t: {} };
+export { defaults } from "./defaults";
 export { getModel, createModel, Model, Prop } from "./model";
 import XML from "./xml";
 export { XML };

package/build/module/middleware.js

@@ -13,19 +13,19 @@ const __RΦ = { m: (k, v) => (t, ...a) => t && Reflect.metadata ? Reflect.metada
             __RΦ.t[id] = t = l;
         }
         return t;
-    }, t: { [311]: { RΦ: t => ({ TΦ: "|", t: [__RΦ.a(12), __RΦ.a(308)] }) }, [12]: { RΦ: t => ({ TΦ: "n" }) }, [308]: { TΦ: "5", name: "ChainableOptions" }, [314]: { RΦ: t => ({ TΦ: "[", e: __RΦ.a(313) }) }, [313]: { RΦ: t => ({ TΦ: "O", m: [{ n: "__call", f: "", t: __RΦ.a(4) }] }) }, [4]: { RΦ: t => ({ TΦ: "~" }) }, [317]: { RΦ: t => ({ TΦ: "g", t: __RΦ.a(308), p: [__RΦ.a(315), __RΦ.a(316)] }) }, [315]: { LΦ: t => Object }, [316]: { LΦ: t => Object }, [331]: { RΦ: t => ({ TΦ: "g", t: __RΦ.a(326), p: [__RΦ.a(318), __RΦ.a(22), __RΦ.a(8)] }) }, [326]: { LΦ: t => Object }, [318]: { RΦ: t => ({ TΦ: "O", m: [{ n: "__call", f: "", t: __RΦ.a(4) }] }) }, [22]: { RΦ: t => ({ TΦ: "V" }) }, [8]: { RΦ: t => ({ TΦ: "U" }) }, [343]: { RΦ: t => ({ TΦ: "g", t: __RΦ.a(335), p: [__RΦ.a(346), __RΦ.a(1), __RΦ.a(10)] }) }, [335]: { LΦ: t => Object }, [346]: { RΦ: t => ({ TΦ: "O", m: [{ n: "__call", f: "", t: __RΦ.a(4) }] }) }, [1]: { RΦ: t => ({ TΦ: "~" }) }, [10]: { RΦ: t => ({ TΦ: "u" }) }, [341]: { LΦ: t => Object }, [342]: { LΦ: t => Object } } };
+    }, t: { [112]: { RΦ: t => ({ TΦ: "|", t: [__RΦ.a(12), __RΦ.a(109)] }) }, [12]: { RΦ: t => ({ TΦ: "n" }) }, [109]: { TΦ: "5", name: "ChainableOptions" }, [115]: { RΦ: t => ({ TΦ: "[", e: __RΦ.a(114) }) }, [114]: { RΦ: t => ({ TΦ: "O", m: [{ n: "__call", f: "", t: __RΦ.a(4) }] }) }, [4]: { RΦ: t => ({ TΦ: "~" }) }, [118]: { RΦ: t => ({ TΦ: "g", t: __RΦ.a(109), p: [__RΦ.a(116), __RΦ.a(117)] }) }, [116]: { LΦ: t => Object }, [117]: { LΦ: t => Object }, [137]: { RΦ: t => ({ TΦ: "g", t: __RΦ.a(132), p: [__RΦ.a(119), __RΦ.a(22), __RΦ.a(8)] }) }, [132]: { LΦ: t => Object }, [119]: { RΦ: t => ({ TΦ: "O", m: [{ n: "__call", f: "", t: __RΦ.a(4) }] }) }, [22]: { RΦ: t => ({ TΦ: "V" }) }, [8]: { RΦ: t => ({ TΦ: "U" }) }, [149]: { RΦ: t => ({ TΦ: "g", t: __RΦ.a(141), p: [__RΦ.a(152), __RΦ.a(1), __RΦ.a(10)] }) }, [141]: { LΦ: t => Object }, [152]: { RΦ: t => ({ TΦ: "O", m: [{ n: "__call", f: "", t: __RΦ.a(4) }] }) }, [1]: { RΦ: t => ({ TΦ: "~" }) }, [10]: { RΦ: t => ({ TΦ: "u" }) }, [147]: { LΦ: t => Object }, [148]: { LΦ: t => Object } } };
 var IΦChainableOptions = { name: "ChainableOptions", prototype: {}, identity: Symbol("ChainableOptions (interface)") };
-(t => __RΦ.t[308] = t)(IΦChainableOptions);
+(t => __RΦ.t[109] = t)(IΦChainableOptions);
 __RΦ.m("rt:P", ["parent", "middlewares"])(IΦChainableOptions);
 __RΦ.m("rt:m", [])(IΦChainableOptions);
 __RΦ.m("rt:f", "I")(IΦChainableOptions);
-__RΦ.m("rt:t", () => __RΦ.a(311))(IΦChainableOptions.prototype, "parent");
+__RΦ.m("rt:t", () => __RΦ.a(112))(IΦChainableOptions.prototype, "parent");
 __RΦ.m("rt:f", "P")(IΦChainableOptions.prototype, "parent");
-__RΦ.m("rt:t", () => __RΦ.a(314))(IΦChainableOptions.prototype, "middlewares");
+__RΦ.m("rt:t", () => __RΦ.a(115))(IΦChainableOptions.prototype, "middlewares");
 __RΦ.m("rt:f", "P")(IΦChainableOptions.prototype, "middlewares");
-__RΦ.m("rt:t", () => __RΦ.a(311))(IΦChainableOptions.prototype, "parent");
+__RΦ.m("rt:t", () => __RΦ.a(112))(IΦChainableOptions.prototype, "parent");
 __RΦ.m("rt:f", "P")(IΦChainableOptions.prototype, "parent");
-__RΦ.m("rt:t", () => __RΦ.a(314))(IΦChainableOptions.prototype, "middlewares");
+__RΦ.m("rt:t", () => __RΦ.a(115))(IΦChainableOptions.prototype, "middlewares");
 __RΦ.m("rt:f", "P")(IΦChainableOptions.prototype, "middlewares");
 export function* MiddlewareChain(options) {
     do {
@@ -38,9 +38,9 @@ export function* MiddlewareChain(options) {
             return;
     } while (true);
 }
-__RΦ.m("rt:p", [{ n: "options", t: () => __RΦ.a(317), v: null }])(MiddlewareChain);
+__RΦ.m("rt:p", [{ n: "options", t: () => __RΦ.a(118), v: null }])(MiddlewareChain);
 __RΦ.m("rt:f", "F")(MiddlewareChain);
-__RΦ.m("rt:t", () => __RΦ.a(331))(MiddlewareChain);
+__RΦ.m("rt:t", () => __RΦ.a(137))(MiddlewareChain);
 export function resolve(middlewares, context) {
     const next = __RΦ.f(() => {
         const { value: nextMiddleware, done } = middlewares.next();
@@ -52,9 +52,9 @@ export function resolve(middlewares, context) {
         else {
             return nextMiddleware(context, next);
         }
-    }, [__RΦ.m("rt:p", []), __RΦ.m("rt:f", "F>"), __RΦ.m("rt:t", () => __RΦ.a(342))], "next");
+    }, [__RΦ.m("rt:p", []), __RΦ.m("rt:f", "F>"), __RΦ.m("rt:t", () => __RΦ.a(148))], "next");
     return next();
 }
-__RΦ.m("rt:p", [{ n: "middlewares", t: () => __RΦ.a(343), v: null }, { n: "context", t: () => __RΦ.a(341), v: null }])(resolve);
+__RΦ.m("rt:p", [{ n: "middlewares", t: () => __RΦ.a(149), v: null }, { n: "context", t: () => __RΦ.a(147), v: null }])(resolve);
 __RΦ.m("rt:f", "F")(resolve);
-__RΦ.m("rt:t", () => __RΦ.a(342))(resolve);
+__RΦ.m("rt:t", () => __RΦ.a(148))(resolve);

package/build/module/model/index.d.ts

@@ -0,0 +1,24 @@
+import "reflect-metadata";
+import type { Constructor } from "typescript-rtti";
+import { XMLModelOptions, XMLModelPropertyOptions, CreateXMLModelOptions } from "./types";
+import { XMLRoot } from "../types";
+export declare class XMLModel<T = any> {
+    readonly type: Constructor<T>;
+    options: XMLModelOptions<T>;
+    constructor(type: Constructor<T>, options: CreateXMLModelOptions<T>);
+    fromXML(xml: XMLRoot | string): T;
+    toXML(instance: object): XMLRoot;
+    get reflectedClass(): import("typescript-rtti").ReflectedClass<Constructor<T>>;
+    resolveAllProperties(): Map<string, XMLModelPropertyOptions<any> & {
+        model: any;
+    }>;
+}
+export declare function createModel<T>(type: Constructor<T>, options: CreateXMLModelOptions<T>): XMLModel<T>;
+declare type ModelID<T> = Constructor<T>;
+export declare const Models: Map<ModelID<unknown>, XMLModel<unknown>>;
+export declare function findModel<T>(id: ModelID<T>): XMLModel<T> | undefined;
+export declare function getModel<T>(id: ModelID<T>): XMLModel<T>;
+declare function ModelDecoratorFactory<T>(options?: CreateXMLModelOptions<T>): (constructor: Constructor<T>) => void;
+export { ModelDecoratorFactory as Model };
+export { Prop } from "./property";
+import "../defaults/models";