xml-model 0.1.0

package/.eslintignore

@@ -0,0 +1,3 @@
+.eslintrc.js
+build
+register-ts-node.js

package/.eslintrc.js

@@ -0,0 +1,6 @@
+module.exports = {
+  root: true,
+  parser: "@typescript-eslint/parser",
+  plugins: ["@typescript-eslint"],
+  extends: ["eslint:recommended", "plugin:@typescript-eslint/recommended"],
+};

package/.gitignore

@@ -0,0 +1,2 @@
+node_modules
+build

package/.vscode/launch.json

@@ -0,0 +1,21 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "type": "node",
+      "request": "launch",
+      "name": "Mocha All",
+      "program": "${workspaceFolder}/node_modules/mocha/bin/_mocha",
+      "args": [
+        "-r",
+        "./register-ts-node",
+        "--timeout",
+        "999999",
+        "--colors",
+        "${workspaceFolder}/src/**/*.spec.ts"
+      ],
+      "console": "integratedTerminal",
+      "internalConsoleOptions": "neverOpen"
+    }
+  ]
+}

package/.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+  "editor.tabSize": 2
+}

package/README.md

@@ -0,0 +1,7 @@
+# XML Model
+
+## Usage
+needs [typescript-rtti](https://github.com/typescript-rtti/typescript-rtti) and [ttypescript](https://github.com/cevek/ttypescript) to work
+
+## Documentation
+check source

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

@@ -0,0 +1,14 @@
+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/main/defaults/index.js

@@ -0,0 +1,165 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaults = void 0;
+const __RΦ = { m: (k, v) => (t, ...a) => t && Reflect.metadata ? Reflect.metadata(k, v)(t, ...a) : void 0, f: (f, d, n) => (d.forEach(d => d(f)), Object.defineProperty(f, "name", { value: n, writable: false }), f), c: (c, d, dp, dsp, n) => (d.forEach(d => d(c)), dp.forEach(([p, d]) => d(c.prototype, p)), dsp.forEach(([p, d]) => d(c, p)), n ? Object.defineProperty(c, "name", { value: n, writable: false }) : undefined, c), r: (o, a) => (Object.assign(o, a)), a: id => {
+        let t = __RΦ.t[id];
+        if (t === void 0)
+            return void 0;
+        if (t.RΦ) {
+            let r = t.RΦ;
+            delete t.RΦ;
+            __RΦ.r(t, r(t));
+        }
+        else if (t.LΦ) {
+            let l = t.LΦ();
+            delete t.LΦ;
+            __RΦ.t[id] = t = l;
+        }
+        return t;
+    }, t: {} };
+const model_1 = require("../model");
+const kebabCase_1 = __importDefault(require("lodash/kebabCase"));
+exports.defaults = {
+    fromXML() {
+        throw new TypeError("you should define 'defaults.fromXML' yourself or provide a 'fromXML' function to @Model() decorator's options");
+    },
+    propertyResolveSourceElements(context) {
+        var _a;
+        // We assume context.xml.elements is a single tag containing all the props
+        // FIXME: is it safe ?
+        const innerElements = ((_a = context.xml.elements[0]) === null || _a === void 0 ? void 0 : _a.elements) || [];
+        return innerElements.filter((el) => context.property.isSourceElement(el, context));
+    },
+    propertySourceElementsFilter(element, context) {
+        return context.property.tagname == element.name;
+    },
+    propertyFromXML(context) {
+        // TODO: handle inline
+        const prop = context.property;
+        const elements = context.elements;
+        const type = context.property.reflected.type;
+        if (prop.reflected.isOptional && elements.length === 0) {
+            return undefined;
+        }
+        if (type.is("class")) {
+            const model = (0, model_1.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 &&
+                elements.every((el) => el.name === prop.tagname)) {
+                // we assume our array is contained in xml.elements
+                arrayEl = { elements };
+            }
+            if (arrayEl.elements) {
+                const elType = type.elementType;
+                if (elType.is("class")) {
+                    const model = (0, model_1.getModel)(elType.class);
+                    const xmlInstances = arrayEl.elements.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 = (0, model_1.getModel)(firstTypeCtor);
+                    return model.fromXML({ elements });
+                }
+            }
+        }
+        // TODO: should warn ???
+        return undefined;
+    },
+    /* Object -> XML */
+    toXML({ properties, model }) {
+        const elements = [];
+        model.options.properties.options.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];
+                // overwrite tagnames
+                _xml.elements.forEach((el) => {
+                    (el.name = prop.tagname), // TODO: configurable ?
+                        elements.push(el);
+                });
+            }
+        });
+        return {
+            elements: [
+                {
+                    type: "element",
+                    name: model.options.tagname,
+                    elements,
+                },
+            ],
+        };
+    },
+    tagnameFromModel(model) {
+        return (0, kebabCase_1.default)(model.type.name);
+    },
+    tagnameFromProperty(property) {
+        return (0, kebabCase_1.default)(String(property.name));
+    },
+    propertyToXML(context) {
+        const property = context.property;
+        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 = (0, model_1.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 = (0, model_1.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 = (0, model_1.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/main/defaults/models.d.ts

@@ -0,0 +1 @@
+export {};

package/build/main/defaults/models.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const __RΦ = { m: (k, v) => (t, ...a) => t && Reflect.metadata ? Reflect.metadata(k, v)(t, ...a) : void 0, f: (f, d, n) => (d.forEach(d => d(f)), Object.defineProperty(f, "name", { value: n, writable: false }), f), c: (c, d, dp, dsp, n) => (d.forEach(d => d(c)), dp.forEach(([p, d]) => d(c.prototype, p)), dsp.forEach(([p, d]) => d(c, p)), n ? Object.defineProperty(c, "name", { value: n, writable: false }) : undefined, c), r: (o, a) => (Object.assign(o, a)), a: id => {
+        let t = __RΦ.t[id];
+        if (t === void 0)
+            return void 0;
+        if (t.RΦ) {
+            let r = t.RΦ;
+            delete t.RΦ;
+            __RΦ.r(t, r(t));
+        }
+        else if (t.LΦ) {
+            let l = t.LΦ();
+            delete t.LΦ;
+            __RΦ.t[id] = t = l;
+        }
+        return t;
+    }, t: { [4]: { RΦ: t => ({ TΦ: "~" }) }, [1225]: { RΦ: t => ({ TΦ: "O", m: [{ n: "elements", f: "", t: __RΦ.a(1223) }] }) }, [1223]: { RΦ: t => ({ TΦ: "[", e: __RΦ.a(1044) }) }, [1044]: { RΦ: t => ({ TΦ: "O", m: [{ n: "type", f: "", t: __RΦ.a(1045) }, { n: "name", f: "", t: __RΦ.a(13) }, { n: "attributes", f: "?", t: __RΦ.a(1043) }, { n: "elements", f: "", t: __RΦ.a(1049) }] }) }, [1045]: { LΦ: t => "element" }, [13]: { LΦ: t => String }, [1043]: { RΦ: t => ({ TΦ: "|", t: [__RΦ.a(10), __RΦ.a(1042)] }) }, [10]: { RΦ: t => ({ TΦ: "u" }) }, [1042]: { LΦ: t => require("xml-js/types").IΦAttributes }, [1049]: { RΦ: t => ({ TΦ: "|", t: [__RΦ.a(166), __RΦ.a(1048)] }) }, [166]: { RΦ: t => ({ TΦ: "O", m: [] }) }, [1048]: { RΦ: t => ({ TΦ: "T", e: [{ t: __RΦ.a(1047) }] }) }, [1047]: { RΦ: t => ({ TΦ: "O", m: [{ n: "type", f: "", t: __RΦ.a(1024) }, { n: "text", f: "", t: __RΦ.a(13) }] }) }, [1024]: { LΦ: t => "text" }, [1246]: { RΦ: t => ({ TΦ: "O", m: [{ n: "elements", f: "", t: __RΦ.a(1223) }] }) }, [14]: { LΦ: t => Number }, [1272]: { RΦ: t => ({ TΦ: "O", m: [{ n: "elements", f: "", t: __RΦ.a(2988) }] }) }, [2988]: { RΦ: t => ({ TΦ: "[", e: __RΦ.a(2986) }) }, [2986]: { RΦ: t => ({ TΦ: "O", m: [{ n: "type", f: "", t: __RΦ.a(13) }, { n: "name", f: "", t: __RΦ.a(13) }] }) }, [20]: { LΦ: t => Boolean } } };
+const model_1 = require("../model");
+const xml_1 = require("../xml");
+// string is <string>value</string>
+(0, model_1.createModel)(String, {
+    toXML: __RΦ.f((ctx) => {
+        return {
+            elements: [(0, xml_1.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(1225))], "toXML"),
+    fromXML: __RΦ.f((ctx) => {
+        return String((0, xml_1.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>
+(0, model_1.createModel)(Number, {
+    toXML: __RΦ.f((ctx) => {
+        return {
+            elements: [(0, xml_1.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(1246))], "toXML"),
+    fromXML: __RΦ.f((ctx) => {
+        return Number((0, xml_1.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>
+(0, model_1.createModel)(Boolean, {
+    toXML: __RΦ.f((ctx) => {
+        return {
+            elements: [
+                Object.assign({ type: "element", name: "boolean" }, (0, xml_1.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(1272))], "toXML"),
+    fromXML: __RΦ.f((ctx) => {
+        return Boolean((0, xml_1.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/main/index.d.ts

@@ -0,0 +1,5 @@
+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/main/index.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XML = exports.Prop = exports.Model = exports.createModel = exports.getModel = exports.defaults = void 0;
+const __RΦ = { m: (k, v) => (t, ...a) => t && Reflect.metadata ? Reflect.metadata(k, v)(t, ...a) : void 0, f: (f, d, n) => (d.forEach(d => d(f)), Object.defineProperty(f, "name", { value: n, writable: false }), f), c: (c, d, dp, dsp, n) => (d.forEach(d => d(c)), dp.forEach(([p, d]) => d(c.prototype, p)), dsp.forEach(([p, d]) => d(c, p)), n ? Object.defineProperty(c, "name", { value: n, writable: false }) : undefined, c), r: (o, a) => (Object.assign(o, a)), a: id => {
+        let t = __RΦ.t[id];
+        if (t === void 0)
+            return void 0;
+        if (t.RΦ) {
+            let r = t.RΦ;
+            delete t.RΦ;
+            __RΦ.r(t, r(t));
+        }
+        else if (t.LΦ) {
+            let l = t.LΦ();
+            delete t.LΦ;
+            __RΦ.t[id] = t = l;
+        }
+        return t;
+    }, t: {} };
+var defaults_1 = require("./defaults");
+Object.defineProperty(exports, "defaults", { enumerable: true, get: function () { return defaults_1.defaults; } });
+var model_1 = require("./model");
+Object.defineProperty(exports, "getModel", { enumerable: true, get: function () { return model_1.getModel; } });
+Object.defineProperty(exports, "createModel", { enumerable: true, get: function () { return model_1.createModel; } });
+Object.defineProperty(exports, "Model", { enumerable: true, get: function () { return model_1.Model; } });
+Object.defineProperty(exports, "Prop", { enumerable: true, get: function () { return model_1.Prop; } });
+const xml_1 = __importDefault(require("./xml"));
+exports.XML = xml_1.default;

package/build/main/middleware.d.ts

@@ -0,0 +1,9 @@
+export declare type Middleware<C, T> = (context: C, next: () => T) => T;
+interface ChainableOptions<C, T> {
+    parent: ChainableOptions<C, T> | null;
+    middlewares: Middleware<C, T>[];
+}
+export declare function MiddlewareChain<C, T>(options: ChainableOptions<C, T>): Generator<Middleware<C, T>, void, unknown>;
+declare type MiddlewareChain<C, T> = Iterator<Middleware<C, T>>;
+export declare function resolve<C, T>(middlewares: MiddlewareChain<C, T>, context: C): T;
+export {};

package/build/main/middleware.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolve = exports.MiddlewareChain = void 0;
+const __RΦ = { m: (k, v) => (t, ...a) => t && Reflect.metadata ? Reflect.metadata(k, v)(t, ...a) : void 0, f: (f, d, n) => (d.forEach(d => d(f)), Object.defineProperty(f, "name", { value: n, writable: false }), f), c: (c, d, dp, dsp, n) => (d.forEach(d => d(c)), dp.forEach(([p, d]) => d(c.prototype, p)), dsp.forEach(([p, d]) => d(c, p)), n ? Object.defineProperty(c, "name", { value: n, writable: false }) : undefined, c), r: (o, a) => (Object.assign(o, a)), a: id => {
+        let t = __RΦ.t[id];
+        if (t === void 0)
+            return void 0;
+        if (t.RΦ) {
+            let r = t.RΦ;
+            delete t.RΦ;
+            __RΦ.r(t, r(t));
+        }
+        else if (t.LΦ) {
+            let l = t.LΦ();
+            delete t.LΦ;
+            __RΦ.t[id] = t = l;
+        }
+        return t;
+    }, t: { [102]: { RΦ: t => ({ TΦ: "|", t: [__RΦ.a(12), __RΦ.a(99)] }) }, [12]: { RΦ: t => ({ TΦ: "n" }) }, [99]: { TΦ: "5", name: "ChainableOptions" }, [105]: { RΦ: t => ({ TΦ: "[", e: __RΦ.a(104) }) }, [104]: { RΦ: t => ({ TΦ: "O", m: [{ n: "__call", f: "", t: __RΦ.a(4) }] }) }, [4]: { RΦ: t => ({ TΦ: "~" }) }, [108]: { RΦ: t => ({ TΦ: "g", t: __RΦ.a(99), p: [__RΦ.a(106), __RΦ.a(107)] }) }, [106]: { LΦ: t => Object }, [107]: { LΦ: t => Object }, [127]: { RΦ: t => ({ TΦ: "g", t: __RΦ.a(122), p: [__RΦ.a(109), __RΦ.a(22), __RΦ.a(8)] }) }, [122]: { LΦ: t => Object }, [109]: { RΦ: t => ({ TΦ: "O", m: [{ n: "__call", f: "", t: __RΦ.a(4) }] }) }, [22]: { RΦ: t => ({ TΦ: "V" }) }, [8]: { RΦ: t => ({ TΦ: "U" }) }, [139]: { RΦ: t => ({ TΦ: "g", t: __RΦ.a(131), p: [__RΦ.a(142), __RΦ.a(1), __RΦ.a(10)] }) }, [131]: { LΦ: t => Object }, [142]: { RΦ: t => ({ TΦ: "O", m: [{ n: "__call", f: "", t: __RΦ.a(4) }] }) }, [1]: { RΦ: t => ({ TΦ: "~" }) }, [10]: { RΦ: t => ({ TΦ: "u" }) }, [137]: { LΦ: t => Object }, [138]: { LΦ: t => Object } } };
+var IΦChainableOptions = { name: "ChainableOptions", prototype: {}, identity: Symbol("ChainableOptions (interface)") };
+(t => __RΦ.t[99] = 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(102))(IΦChainableOptions.prototype, "parent");
+__RΦ.m("rt:f", "P")(IΦChainableOptions.prototype, "parent");
+__RΦ.m("rt:t", () => __RΦ.a(105))(IΦChainableOptions.prototype, "middlewares");
+__RΦ.m("rt:f", "P")(IΦChainableOptions.prototype, "middlewares");
+__RΦ.m("rt:t", () => __RΦ.a(102))(IΦChainableOptions.prototype, "parent");
+__RΦ.m("rt:f", "P")(IΦChainableOptions.prototype, "parent");
+__RΦ.m("rt:t", () => __RΦ.a(105))(IΦChainableOptions.prototype, "middlewares");
+__RΦ.m("rt:f", "P")(IΦChainableOptions.prototype, "middlewares");
+function* MiddlewareChain(options) {
+    do {
+        for (let index = options.middlewares.length - 1; index >= 0; index--) {
+            yield options.middlewares[index];
+        }
+        if (options.parent)
+            options = options.parent;
+        else
+            return;
+    } while (true);
+}
+exports.MiddlewareChain = MiddlewareChain;
+__RΦ.m("rt:p", [{ n: "options", t: () => __RΦ.a(108), v: null }])(MiddlewareChain);
+__RΦ.m("rt:f", "F")(MiddlewareChain);
+__RΦ.m("rt:t", () => __RΦ.a(127))(MiddlewareChain);
+function resolve(middlewares, context) {
+    const next = __RΦ.f(() => {
+        const { value: nextMiddleware, done } = middlewares.next();
+        if (done || !nextMiddleware) {
+            // previous middlewares should have returned a value before
+            // TODO: dedicated error class
+            throw new Error("no more next middleware");
+        }
+        else {
+            return nextMiddleware(context, next);
+        }
+    }, [__RΦ.m("rt:p", []), __RΦ.m("rt:f", "F>"), __RΦ.m("rt:t", () => __RΦ.a(138))], "next");
+    return next();
+}
+exports.resolve = resolve;
+__RΦ.m("rt:p", [{ n: "middlewares", t: () => __RΦ.a(139), v: null }, { n: "context", t: () => __RΦ.a(137), v: null }])(resolve);
+__RΦ.m("rt:f", "F")(resolve);
+__RΦ.m("rt:t", () => __RΦ.a(138))(resolve);

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

@@ -0,0 +1,26 @@
+import "reflect-metadata";
+import type { Constructor } from "typescript-rtti";
+import { XMLModelOptions } from "./types";
+import { XMLRoot } from "../types";
+export interface XMLModelConversionOptions<T> {
+    fromXML?: XMLModelOptions<T>["fromXML"]["middlewares"][number];
+    tagname?: string;
+    toXML?: XMLModelOptions<T>["toXML"]["middlewares"][number];
+}
+export declare class XMLModel<T = any> {
+    readonly type: Constructor<T>;
+    options: XMLModelOptions<T>;
+    constructor(type: Constructor<T>, options: XMLModelConversionOptions<T>);
+    fromXML(xml: XMLRoot | string): T;
+    toXML(instance: object): XMLRoot;
+    get reflectedClass(): import("typescript-rtti").ReflectedClass<Constructor<T>>;
+}
+export declare function createModel<T>(type: Constructor<T>, options: XMLModelConversionOptions<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?: XMLModelConversionOptions<T>): (constructor: Constructor<T>) => void;
+export { ModelDecoratorFactory as Model };
+export { Prop } from "./property";
+import "../defaults/models";