xml-model 0.1.0

package/build/main/xml.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setAttribute = exports.addElement = exports.fromContent = exports.getContent = exports.stringify = exports.parse = 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: { [13]: { LΦ: t => String }, [93]: { RΦ: t => ({ TΦ: "O", m: [{ n: "elements", f: "", t: __RΦ.a(92) }] }) }, [92]: { RΦ: t => ({ TΦ: "[", e: __RΦ.a(91) }) }, [91]: { LΦ: t => require("xml-js/types").IΦElement }, [1002]: { RΦ: t => ({ TΦ: "|", t: [__RΦ.a(10), __RΦ.a(999)] }) }, [10]: { RΦ: t => ({ TΦ: "u" }) }, [999]: { LΦ: t => require("xml-js/types").IΦJS2XML }, [1027]: { RΦ: t => ({ TΦ: "|", t: [__RΦ.a(10), __RΦ.a(13), __RΦ.a(14), __RΦ.a(17), __RΦ.a(19)] }) }, [14]: { LΦ: t => Number }, [17]: { RΦ: t => ({ TΦ: "0" }) }, [19]: { RΦ: t => ({ TΦ: "1" }) }, [46]: { LΦ: t => "" }, [1043]: { RΦ: t => ({ TΦ: "|", t: [__RΦ.a(10), __RΦ.a(1042)] }) }, [1042]: { LΦ: t => require("xml-js/types").IΦAttributes }, [22]: { RΦ: t => ({ TΦ: "V" }) } } };
+const xml_js_1 = require("xml-js");
+function parse(string) {
+    return (0, xml_js_1.xml2js)(string);
+}
+exports.parse = parse;
+__RΦ.m("rt:p", [{ n: "string", t: () => __RΦ.a(13), v: null }])(parse);
+__RΦ.m("rt:f", "F")(parse);
+__RΦ.m("rt:t", () => __RΦ.a(93))(parse);
+function stringify(xml, options) {
+    return (0, xml_js_1.js2xml)(xml, options);
+}
+exports.stringify = stringify;
+__RΦ.m("rt:p", [{ n: "xml", t: () => __RΦ.a(93), v: null }, { n: "options", t: () => __RΦ.a(1002), v: null, f: "?" }])(stringify);
+__RΦ.m("rt:f", "F")(stringify);
+__RΦ.m("rt:t", () => __RΦ.a(13))(stringify);
+function getContent(xml) {
+    var _a;
+    if (((_a = xml.elements) === null || _a === void 0 ? void 0 : _a.length) === 1) {
+        const content = xml.elements[0];
+        if (content.type === "text")
+            return content.text;
+    }
+    if (!xml.elements)
+        return "";
+    throw new TypeError(`can't get text from XMLElement: ${JSON.stringify(xml)}`);
+}
+exports.getContent = getContent;
+__RΦ.m("rt:p", [{ n: "xml", t: () => __RΦ.a(91), v: null }])(getContent);
+__RΦ.m("rt:f", "F")(getContent);
+__RΦ.m("rt:t", () => __RΦ.a(1027))(getContent);
+function fromContent(content = "", tag, attributes) {
+    const el = {
+        elements: content ? [{ type: "text", text: String(content) }] : [],
+    };
+    if (tag)
+        el.name = tag;
+    if (attributes) {
+        if (!el.name)
+            throw new TypeError("please provide a name if you want to provide attributes");
+        el.attributes = attributes;
+    }
+    if (el.name)
+        el.type = "element";
+    return el;
+}
+exports.fromContent = fromContent;
+__RΦ.m("rt:p", [{ n: "content", t: () => __RΦ.a(46), v: function () { return ""; } }, { n: "tag", t: () => __RΦ.a(13), v: null, f: "?" }, { n: "attributes", t: () => __RΦ.a(1043), v: null, f: "?" }])(fromContent);
+__RΦ.m("rt:f", "F")(fromContent);
+__RΦ.m("rt:t", () => __RΦ.a(91))(fromContent);
+function addElement(xml, element) {
+    if (!xml.elements)
+        xml.elements = [];
+    xml.elements.push(element);
+}
+exports.addElement = addElement;
+__RΦ.m("rt:p", [{ n: "xml", t: () => __RΦ.a(91), v: null }, { n: "element", t: () => __RΦ.a(91), v: null }])(addElement);
+__RΦ.m("rt:f", "F")(addElement);
+__RΦ.m("rt:t", () => __RΦ.a(22))(addElement);
+function setAttribute(xml, attribute, value) {
+    if (!xml.attributes)
+        xml.attributes = {};
+    xml.attributes[attribute] = value;
+}
+exports.setAttribute = setAttribute;
+__RΦ.m("rt:p", [{ n: "xml", t: () => __RΦ.a(91), v: null }, { n: "attribute", t: () => __RΦ.a(13), v: null }, { n: "value", t: () => __RΦ.a(13), v: null }])(setAttribute);
+__RΦ.m("rt:f", "F")(setAttribute);
+__RΦ.m("rt:t", () => __RΦ.a(22))(setAttribute);
+const XML = {
+    parse,
+    stringify,
+    fromContent,
+    getContent,
+    addElement,
+    setAttribute,
+};
+exports.default = XML;

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

@@ -0,0 +1,13 @@
+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"];
+};
+export declare const defaults: defaults;
+export {};

package/build/module/defaults/index.js

@@ -0,0 +1,71 @@
+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: { [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";
+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");
+    },
+    tagnameFromClass(ctx) {
+        return kebabCase(ctx.class.name);
+    },
+    tagnameFromProperty(context) {
+        return kebabCase(context.property);
+    },
+    /* Handle Property */
+    handleProperty(context) {
+        const type = context.type;
+        if (type.is("class")) {
+            handleClassProperty(context);
+        }
+        else if (type.is("array") && type.elementType.is("class")) {
+            handleClassArrayProperty(context);
+        }
+    },
+};

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

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

package/build/module/defaults/models.js

@@ -0,0 +1,27 @@
+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Φ: "~" }) }, [384]: { LΦ: t => LΦ_0.IΦElement }, [13]: { LΦ: t => String }, [14]: { LΦ: t => Number } } };
+import { createModel } from "../model";
+import { getContent as getXMLContent, fromContent as xmlFromContent, } from "../xml";
+import * as LΦ_0 from "xml-js/types";
+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"),
+});
+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"),
+});

package/build/module/errors.d.ts

@@ -0,0 +1,3 @@
+export declare class NoExplicitTypeError extends Error {
+    constructor(typeName: string, propertyKey: string, parameterIndex?: number, argName?: string);
+}

package/build/module/errors.js

@@ -0,0 +1,37 @@
+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: { [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 => __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);

package/build/module/index.d.ts

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

package/build/module/index.js

@@ -0,0 +1,19 @@
+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: {} };
+export { getModel, createModel, Model, Prop } from "./model";
+import XML from "./xml";
+export { XML };

package/build/module/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/module/middleware.js

@@ -0,0 +1,60 @@
+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: { [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 } } };
+var IΦChainableOptions = { name: "ChainableOptions", prototype: {}, identity: Symbol("ChainableOptions (interface)") };
+(t => __RΦ.t[308] = 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:f", "P")(IΦChainableOptions.prototype, "parent");
+__RΦ.m("rt:t", () => __RΦ.a(314))(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:f", "P")(IΦChainableOptions.prototype, "parent");
+__RΦ.m("rt:t", () => __RΦ.a(314))(IΦChainableOptions.prototype, "middlewares");
+__RΦ.m("rt:f", "P")(IΦChainableOptions.prototype, "middlewares");
+export 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);
+}
+__RΦ.m("rt:p", [{ n: "options", t: () => __RΦ.a(317), v: null }])(MiddlewareChain);
+__RΦ.m("rt:f", "F")(MiddlewareChain);
+__RΦ.m("rt:t", () => __RΦ.a(331))(MiddlewareChain);
+export 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(342))], "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:f", "F")(resolve);
+__RΦ.m("rt:t", () => __RΦ.a(342))(resolve);

package/build/module/model.d.ts

@@ -0,0 +1,71 @@
+import "reflect-metadata";
+import { ReflectedTypeRef } from "typescript-rtti";
+import { XMLToObjectOptions, XMLToObjectMiddlewareContext } from "./xml-to-object";
+import { XMLFromObjectOptions, XMLFromObjectMiddlewareContext } from "./xml-from-object";
+import { ClassType, XMLElement } from "./types";
+declare type ModelProperty = string;
+interface XMLFromObjectPropHandlerContext extends XMLFromObjectMiddlewareContext {
+    property: ModelProperty;
+    value: unknown;
+    type: ReflectedTypeRef;
+    tagname: string | null;
+}
+interface XMLToObjectPropHandlerContext extends XMLToObjectMiddlewareContext {
+    element: XMLElement;
+}
+export interface PropertyConversionOptions {
+    property: ModelProperty;
+    type: ReflectedTypeRef;
+    forElement: (el: XMLElement) => boolean;
+    handleElement: (context: XMLToObjectPropHandlerContext) => void;
+    handleProperty: (context: XMLFromObjectMiddlewareContext) => void;
+}
+export interface XMLToObjectInstantiateContext<T> extends XMLToObjectMiddlewareContext {
+    class: ClassType;
+}
+export declare type InstantiateHandler<T> = (ctx: XMLToObjectInstantiateContext<T>) => T;
+export interface ObjectConversionOptions {
+    fromXML?: XMLToObjectOptions["middlewares"][number];
+    instantiate?: InstantiateHandler<unknown>;
+    tagname?: string;
+    toXML?: XMLFromObjectOptions["middlewares"][number];
+}
+interface ConversionOptions {
+    fromXML: XMLToObjectOptions;
+    toXML: XMLFromObjectOptions;
+}
+export declare class XMLModel {
+    readonly type: ClassType;
+    readonly options: ObjectConversionOptions;
+    conversionOptions?: ConversionOptions;
+    constructor(type: ClassType, options: ObjectConversionOptions);
+    private resolveConversionOptions;
+    private getConversionOptions;
+    recordFromXMLElement(xml: XMLElement): import("./types").UnknownRecord;
+    fromXMLElement(xml: XMLElement): unknown;
+    toXMLElement(instance: any): XMLElement;
+}
+export declare function createModel(...args: ConstructorParameters<typeof XMLModel>): XMLModel;
+export declare const Models: Map<ClassType<any>, XMLModel>;
+export declare function findModel(type: ClassType): XMLModel | undefined;
+export declare function getModel(type: ClassType): XMLModel;
+declare function ModelDecoratorFactory(options?: ObjectConversionOptions): (constructor: ClassType) => void;
+export { ModelDecoratorFactory as Model };
+export declare type TagnameFromPropertyResolver = (context: {
+    property: ModelProperty;
+    type: ReflectedTypeRef;
+    value: unknown;
+}) => string | null;
+export interface PropDecoratorOptions {
+    tagname?: string;
+    fromElement?: string | RegExp | ((element: XMLElement) => boolean);
+    toTagname?: TagnameFromPropertyResolver | ReturnType<TagnameFromPropertyResolver>;
+    toXML?: (context: XMLFromObjectPropHandlerContext) => XMLElement;
+    handleProperty?: (context: XMLFromObjectPropHandlerContext) => void;
+    fromXML?: (context: XMLToObjectPropHandlerContext) => unknown;
+    handleElement?: (context: XMLToObjectPropHandlerContext) => void;
+    ignore?: boolean;
+}
+declare function PropDecoratorFactory(options?: PropDecoratorOptions): (prototype: any, property: ModelProperty) => void;
+export { PropDecoratorFactory as Prop };
+import "./defaults/models";