xml-model 1.3.2 → 2.0.0-beta.1

package/dist/xml/codec.js

@@ -0,0 +1,385 @@
+import { z } from "zod";
+import { XML } from "./xml-js.js";
+import { getUserOptions } from "./schema-meta.js";
+import { kebabCase } from "../util/kebab-case.js";
+import { isZodType } from "../util/zod.js";
+function assertSingleElement(xml) {
+  if (xml.length !== 1) throw new Error(`Expected single XML element, got ${xml.length}`);
+}
+function assertSingleRoot(xml) {
+  assertSingleElement(xml);
+  if (!Array.isArray(xml[0].elements)) throw new Error(`Expected element with children list`);
+}
+function normalizeCodecOptions(schema, options = {}) {
+  let _defaultOptions;
+  const defaultOptions = () => {
+    if (!_defaultOptions) {
+      _defaultOptions = resolveDefault(schema);
+      if (!_defaultOptions) {
+        throw new Error(
+          `Failed to resolve default codec options for schema of type ${schema.type}`
+        );
+      }
+    }
+    return _defaultOptions;
+  };
+  const userTagname = options.tagname;
+  const tagname = typeof userTagname === "string" ? () => userTagname : typeof userTagname === "function" ? userTagname : () => {
+    throw new Error("tagname is not defined");
+  };
+  const userPropTagname = options.propertyTagname;
+  const propertyTagname = typeof userPropTagname === "string" ? () => userPropTagname : typeof userPropTagname === "function" ? userPropTagname : (ctx) => kebabCase(ctx.name);
+  const inlineProperty = options.inlineProperty ?? false;
+  const userMatch = options.propertyMatch;
+  const propertyMatch = userMatch instanceof RegExp ? (el) => userMatch.test(el.name) : typeof userMatch === "function" ? userMatch : (el, ctx) => el.name === ctx.tagname;
+  const decode2 = options.decode ?? defaultOptions().decode;
+  const encode2 = options.encode ?? defaultOptions().encode;
+  const result = {
+    schema,
+    tagname,
+    decode: decode2,
+    encode: encode2,
+    propertyTagname,
+    inlineProperty,
+    propertyMatch,
+    decodeAsProperty: options.decodeAsProperty ?? function(ctx) {
+      const res = result.decode({ options: result, xml: ctx.property.xml });
+      ctx.result[ctx.property.name] = res;
+    },
+    encodeAsProperty: options.encodeAsProperty ?? function(ctx) {
+      const { property } = ctx;
+      const optsWithTagname = { ...result, tagname: () => property.tagname };
+      const res = result.encode({
+        options: optsWithTagname,
+        // FIXME: we should not rely on type casting
+        data: property.value
+      });
+      if (XML.isEmpty(res)) {
+        return;
+      }
+      if (property.options.inlineProperty) {
+        ctx.result.elements.push(...res.elements);
+      } else {
+        ctx.result.elements.push(res);
+      }
+    }
+  };
+  return result;
+}
+const cache = /* @__PURE__ */ new Map();
+function resolveCodecOptions(schema) {
+  const cached = cache.get(schema);
+  if (cached) return cached;
+  const userOpts = getUserOptions(schema);
+  const options = normalizeCodecOptions(schema, userOpts);
+  cache.set(schema, options);
+  return options;
+}
+const XML_STATE = /* @__PURE__ */ Symbol("xml-model.state");
+function resolvePropertiesCodecOptions(schema) {
+  const shape = schema.def.shape;
+  const options = {};
+  for (const [prop, fieldSchema] of Object.entries(shape)) {
+    options[prop] = resolveCodecOptions(fieldSchema);
+  }
+  return options;
+}
+function decode(schema, xml) {
+  const options = resolveCodecOptions(schema);
+  return options.decode({ options, xml });
+}
+function encode(schema, data) {
+  const options = resolveCodecOptions(schema);
+  return options.encode({ options, data });
+}
+function registerDefault(resolve) {
+  defaults.push(resolve);
+}
+const defaults = [];
+function resolveDefault(schema) {
+  for (let index = defaults.length - 1; index >= 0; index--) {
+    const resolver = defaults[index];
+    const res = resolver(schema);
+    if (res) return res;
+  }
+}
+registerDefault((schema) => {
+  if (schema instanceof z.ZodArray) {
+    const elOptions = resolveCodecOptions(
+      // FIXME: why is this cast needed ?
+      schema.def.element
+    );
+    return normalizeCodecOptions(schema, {
+      decode(ctx) {
+        const { xml } = ctx;
+        if (!xml) return [];
+        return xml.elements.filter((el) => el.type === "element").map((el) => elOptions.decode({ options: elOptions, xml: el }));
+      },
+      // FIXME: when encode method was missing typescript didn't complain
+      encode(ctx) {
+        const values = ctx.data;
+        if (!Array.isArray(values)) throw new Error("expected array");
+        return {
+          type: "element",
+          name: ctx.options.tagname(ctx),
+          attributes: {},
+          elements: values.map((v) => elOptions.encode({ options: elOptions, data: v }))
+        };
+      }
+    });
+  }
+  if (schema instanceof z.ZodOptional) {
+    const inner = schema.def.innerType;
+    if (!isZodType(inner)) throw new Error(`Expected a ZodType, got ${inner}`);
+    const innerOptions = resolveCodecOptions(inner);
+    return normalizeCodecOptions(schema, {
+      decode(ctx) {
+        if (!ctx.xml) return void 0;
+        else return innerOptions.decode(ctx);
+      },
+      encode(ctx) {
+        if (typeof ctx.data === "undefined")
+          return {};
+        else return innerOptions.encode(ctx);
+      }
+    });
+  }
+  if (schema instanceof z.ZodDefault) {
+    const { innerType: inner, defaultValue } = schema.def;
+    if (!isZodType(inner)) throw new Error(`Expected a ZodType, got ${inner}`);
+    const innerOptions = resolveCodecOptions(inner);
+    const getDefault = typeof schema.def.defaultValue === "function" ? schema.def.defaultValue : () => defaultValue;
+    return normalizeCodecOptions(schema, {
+      decode(ctx) {
+        if (!ctx.xml) return getDefault();
+        else return innerOptions.decode(ctx);
+      },
+      encode(ctx) {
+        return innerOptions.encode(ctx);
+      }
+    });
+  }
+  if (schema instanceof z.ZodLazy) {
+    const inner = schema.def.getter();
+    if (!isZodType(inner)) throw new Error(`Expected a ZodType, got ${inner}`);
+    return resolveDefault(inner);
+  }
+  if (schema instanceof z.ZodCodec) {
+    const inSchema = schema.def.in;
+    const outSchema = schema.def.out;
+    if (!isZodType(inSchema))
+      throw new Error(`Expected schema.def.in to be a ZodType, got ${inSchema}`);
+    if (!isZodType(outSchema))
+      throw new Error(`Expected schema.def.out to be a ZodType, got ${outSchema}`);
+    const inputCodecOptions = resolveCodecOptions(inSchema);
+    return normalizeCodecOptions(schema, {
+      decode({ xml }) {
+        const input = inputCodecOptions.decode({ options: inputCodecOptions, xml });
+        return schema.def.transform(input, { value: input, issues: [] });
+      },
+      encode(ctx) {
+        const data = outSchema.encode(ctx.data);
+        const innerOpts = ctx.options.tagname !== inputCodecOptions.tagname ? { ...inputCodecOptions, tagname: ctx.options.tagname } : inputCodecOptions;
+        return innerOpts.encode({ options: innerOpts, data });
+      }
+    });
+  }
+  if (schema instanceof z.ZodLiteral) {
+    const values = schema.def.values;
+    const valuesFromString = Object.fromEntries(values.map((v) => [v.toString(), v]));
+    return normalizeCodecOptions(schema, {
+      decode(ctx) {
+        const raw = XML.getContent(ctx.xml);
+        if (!(raw in valuesFromString))
+          throw new Error(`Could not retrieve literal value from string "${raw}"`);
+        return valuesFromString[raw];
+      },
+      encode(ctx) {
+        return XML.fromContent(String(ctx.data), ctx.options.tagname(ctx));
+      }
+    });
+  }
+  if (schema instanceof z.ZodString) {
+    return normalizeCodecOptions(schema, {
+      decode(ctx) {
+        return XML.getContent(ctx.xml);
+      },
+      encode(ctx) {
+        return XML.fromContent(ctx.data, ctx.options.tagname(ctx));
+      }
+    });
+  }
+  if (schema instanceof z.ZodNumber) {
+    return normalizeCodecOptions(schema, {
+      decode(ctx) {
+        return Number(XML.getContent(ctx.xml));
+      },
+      encode(ctx) {
+        return XML.fromContent(ctx.data.toString(), ctx.options.tagname(ctx));
+      }
+    });
+  }
+  if (schema instanceof z.ZodBoolean) {
+    return normalizeCodecOptions(schema, {
+      decode(ctx) {
+        return XML.getContent(ctx.xml) === "true";
+      },
+      encode(ctx) {
+        return XML.fromContent(ctx.data.toString(), ctx.options.tagname(ctx));
+      }
+    });
+  }
+});
+registerDefault((schema) => {
+  if (schema instanceof z.ZodObject) {
+    const options = resolvePropertiesCodecOptions(schema);
+    return normalizeCodecOptions(schema, {
+      decode(ctx) {
+        const sequence = [];
+        const propContexts = Object.fromEntries(
+          Object.entries(options).map(([name, propOpts]) => {
+            const tagname = propOpts.propertyTagname({ name, options: propOpts });
+            return [
+              name,
+              {
+                name,
+                options: propOpts,
+                tagname,
+                // starts as a collection container; replaced with actual element or null after matching
+                xml: { elements: [] }
+              }
+            ];
+          })
+        );
+        const seenProperties = /* @__PURE__ */ new Set();
+        for (const el of ctx.xml.elements) {
+          if (el.type !== "element") continue;
+          const matches = [];
+          for (const prop in options) {
+            const propCtx = propContexts[prop];
+            if (options[prop].propertyMatch(el, propCtx)) {
+              matches.push(prop);
+              propCtx.xml.elements.push(el);
+            }
+          }
+          if (!matches.length) {
+            sequence.push(el);
+            continue;
+          } else if (matches.length === 1) {
+            const propName = matches[0];
+            if (seenProperties.has(propName)) {
+              const prop = options[propName];
+              if (!prop.inlineProperty)
+                throw new Error(
+                  "Matching multiple elements for a single property is only supported when `inlineProperty` is true"
+                );
+            } else {
+              sequence.push(propName);
+              seenProperties.add(propName);
+            }
+          } else {
+            throw new Error(
+              `Same element was matched by multiple properties: ${matches.join(", ")}`
+            );
+          }
+        }
+        for (const propName in options) {
+          if (!seenProperties.has(propName)) sequence.push(propName);
+        }
+        const result = {};
+        for (const prop in options) {
+          const o = options[prop];
+          const propCtx = propContexts[prop];
+          if (!o.inlineProperty) {
+            const matches = propCtx.xml.elements;
+            if (matches.length === 0) propCtx.xml = null;
+            else {
+              assertSingleElement(matches);
+              propCtx.xml = matches[0];
+            }
+          }
+          o.decodeAsProperty({
+            // @ts-ignore
+            options: ctx.options,
+            xml: ctx.xml,
+            // @ts-ignore
+            property: propCtx,
+            result
+          });
+        }
+        Object.defineProperty(result, XML_STATE, {
+          value: { fieldOrder: sequence },
+          enumerable: false,
+          writable: true,
+          configurable: true
+        });
+        return result;
+      },
+      encode(ctx) {
+        const { data } = ctx;
+        const result = {
+          type: "element",
+          name: ctx.options.tagname(ctx),
+          // already create the attributes record so `attr(...)` encoding handlers don't have to
+          attributes: {},
+          elements: []
+        };
+        const sequence = data[XML_STATE]?.fieldOrder ?? Object.keys(options);
+        for (const item of sequence) {
+          if (typeof item === "string") {
+            const o = options[item];
+            if (!o) {
+              throw new Error(`Failed to resolve property options for sequence item ${item}`);
+            }
+            o.encodeAsProperty({
+              // FIXME should not need type casts
+              options: ctx.options,
+              data,
+              property: {
+                name: item,
+                options: o,
+                tagname: o.propertyTagname({ name: item, options: o }),
+                value: data[item]
+              },
+              result
+            });
+          } else {
+            result.elements.push(item);
+          }
+        }
+        return result;
+      }
+    });
+  }
+});
+function xmlCodec(schema) {
+  const codec = z.codec(z.string(), schema, {
+    decode(xml) {
+      const xmlRoot = XML.parse(xml);
+      const xmlEl = XML.elementFromRoot(xmlRoot);
+      const input = decode(schema, xmlEl);
+      return input;
+    },
+    encode(value) {
+      const xmlEl = encode(
+        schema,
+        // FIXME: value is expected to be of type input<S>
+        // so `schema` should be able or re-encoding its output
+        value
+      );
+      return XML.stringify({ elements: [xmlEl] });
+    }
+  });
+  return codec;
+}
+export {
+  XML_STATE,
+  assertSingleElement,
+  assertSingleRoot,
+  decode,
+  encode,
+  normalizeCodecOptions,
+  registerDefault,
+  xmlCodec
+};
+//# sourceMappingURL=codec.js.map

package/dist/xml/examples.d.ts

@@ -0,0 +1,188 @@
+import { z } from 'zod';
+declare const Engine_base: import('./model').XmlModelConstructor<z.ZodObject<{
+    type: z.ZodString;
+    horsepower: z.ZodNumber;
+}, z.core.$strip>, {
+    type: string;
+    horsepower: number;
+}>;
+/**
+ * A car engine. Demonstrates a basic nested class with one XML attribute
+ * (`type`) and one child element (`horsepower`).
+ */
+export declare class Engine extends Engine_base {
+}
+declare const Vehicle_base: import('./model').XmlModelConstructor<z.ZodObject<{
+    vin: z.ZodString;
+    make: z.ZodString;
+    year: z.ZodNumber;
+}, z.core.$strip>, {
+    vin: string;
+    make: string;
+    year: number;
+}>;
+/**
+ * Base vehicle class. Demonstrates `xml.attr()` for identifier fields and
+ * `xml.prop()` for child-element fields. Custom methods on the class are
+ * available on every parsed instance.
+ */
+export declare class Vehicle extends Vehicle_base {
+    /** Returns a human-readable label for this vehicle. */
+    label(): string;
+}
+declare const Car_base: Omit<typeof Vehicle, keyof import('..').ModelConstructor<S, Inst>> & import('..').ModelConstructor<z.ZodObject<{
+    vin: z.ZodString;
+    make: z.ZodString;
+    year: z.ZodNumber;
+    doors: z.ZodNumber;
+    engine: z.ZodCodec<z.ZodObject<{
+        type: z.ZodString;
+        horsepower: z.ZodNumber;
+    }, z.core.$strip>, z.ZodCustom<Engine, Engine>>;
+}, z.core.$strip>, Vehicle & {
+    vin: string;
+    make: string;
+    year: number;
+    doors: number;
+    engine?: Engine;
+}>;
+/**
+ * Car extends Vehicle using `Vehicle.extend()`, which creates a **true subclass**:
+ * instances are `instanceof Vehicle` and inherit Vehicle's methods (e.g. `label()`).
+ *
+ * Demonstrates:
+ * - chaining `.extend()` to add fields to a parent model
+ * - `xml.prop(Engine)` to embed a nested xmlModel class as a child element
+ */
+export declare class Car extends Car_base {
+}
+declare const SportCar_base: Omit<typeof Car, keyof import('..').ModelConstructor<S, Inst>> & import('..').ModelConstructor<z.ZodObject<{
+    vin: z.ZodString;
+    make: z.ZodString;
+    year: z.ZodNumber;
+    doors: z.ZodNumber;
+    engine: z.ZodCodec<z.ZodObject<{
+        type: z.ZodString;
+        horsepower: z.ZodNumber;
+    }, z.core.$strip>, z.ZodCustom<Engine, Engine>>;
+    topSpeed: z.ZodNumber;
+}, z.core.$strip>, Car & {
+    vin: string;
+    make: string;
+    year: number;
+    doors: number;
+    topSpeed: number;
+    engine?: Engine;
+}>;
+/**
+ * SportCar shows that `.extend()` chains across multiple levels.
+ * Instances are `instanceof SportCar`, `instanceof Car`, and `instanceof Vehicle`.
+ */
+export declare class SportCar extends SportCar_base {
+}
+declare const Motorcycle_base: Omit<typeof Vehicle, keyof import('..').ModelConstructor<S, Inst>> & import('..').ModelConstructor<z.ZodObject<{
+    vin: z.ZodString;
+    make: z.ZodString;
+    year: z.ZodNumber;
+    sidecar: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, Vehicle & {
+    vin: string;
+    make: string;
+    year: number;
+    sidecar?: boolean;
+}>;
+/**
+ * Motorcycle extends Vehicle with an optional boolean field.
+ * When `<sidecar>` is absent from the XML the field is `undefined`;
+ * `toXMLString` omits it entirely.
+ */
+export declare class Motorcycle extends Motorcycle_base {
+}
+declare const Fleet_base: import('./model').XmlModelConstructor<z.ZodObject<{
+    name: z.ZodString;
+    cars: z.ZodArray<z.ZodCodec<z.ZodObject<{
+        vin: z.ZodString;
+        make: z.ZodString;
+        year: z.ZodNumber;
+        doors: z.ZodNumber;
+        engine: z.ZodCodec<z.ZodObject<{
+            type: z.ZodString;
+            horsepower: z.ZodNumber;
+        }, z.core.$strip>, z.ZodCustom<Engine, Engine>>;
+    }, z.core.$strip>, z.ZodCustom<Car, Car>>>;
+    motorcycles: z.ZodArray<z.ZodCodec<z.ZodObject<{
+        vin: z.ZodString;
+        make: z.ZodString;
+        year: z.ZodNumber;
+        sidecar: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodCustom<Motorcycle, Motorcycle>>>;
+}, z.core.$strip>, {
+    name: string;
+    cars: Car[];
+    motorcycles: Motorcycle[];
+}>;
+/**
+ * Fleet demonstrates **inline arrays** of multiple vehicle types.
+ * `inline: true` places each item as a direct sibling element inside the
+ * root tag rather than wrapping them in a container element.
+ */
+export declare class Fleet extends Fleet_base {
+    /** Total number of vehicles across all types in this fleet. */
+    totalVehicles(): number;
+}
+declare const Showroom_base: import('./model').XmlModelConstructor<z.ZodObject<{
+    name: z.ZodString;
+    models: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, {
+    name: string;
+    models: string[];
+}>;
+/**
+ * A showroom holds an inventory of car model names.
+ * Demonstrates a **non-inline** (wrapped) array: all items are nested inside
+ * a single `<models>` container element, as opposed to being direct siblings
+ * of the root element.
+ *
+ * ```xml
+ * <showroom name="Acme Dealers">
+ *   <models>
+ *     <model>Corolla</model>
+ *     <model>Civic</model>
+ *   </models>
+ * </showroom>
+ * ```
+ *
+ * Contrast with `Fleet`, which uses `inline: true` so each `<car>` / `<motorcycle>`
+ * is a direct child of `<fleet>` with no container wrapper.
+ */
+export declare class Showroom extends Showroom_base {
+}
+declare const CarStandalone_base: import('./model').XmlModelConstructor<z.ZodObject<{
+    vin: z.ZodString;
+    make: z.ZodString;
+    year: z.ZodNumber;
+    doors: z.ZodNumber;
+    engine: z.ZodCodec<z.ZodObject<{
+        type: z.ZodString;
+        horsepower: z.ZodNumber;
+    }, z.core.$strip>, z.ZodCustom<Engine, Engine>>;
+}, z.core.$strip>, {
+    vin: string;
+    make: string;
+    year: number;
+    doors: number;
+    engine?: Engine;
+}>;
+/**
+ * Demonstrates the alternative to `.extend()`: passing a manually extended
+ * schema to `xmlModel()`. This produces a **fresh class** with no prototype
+ * link to `Vehicle` — instances are **not** `instanceof Vehicle` and Vehicle's
+ * methods are unavailable.
+ *
+ * Use this pattern when you want a standalone class that reuses a schema shape
+ * but does not need to be part of the parent class hierarchy.
+ */
+export declare class CarStandalone extends CarStandalone_base {
+}
+export {};
+//# sourceMappingURL=examples.d.ts.map

package/dist/xml/index.d.ts

@@ -1,33 +1,6 @@
-import { XMLElement, XMLRoot } from '../types';
-export declare function parse(string: string): XMLRoot;
-export declare const stringify: typeof import('xml-js').js2xml;
-export declare function getContent(xml: XMLElement): string | number | boolean;
-export declare function fromContent(content: string): {
-    elements: [{
-        type: "text";
-        text: string;
-    }] | [];
-};
-export declare function fromContent(content: string, tag: string, attributes?: XMLElement["attributes"]): {
-    type: "element";
-    name: string;
-    attributes?: XMLElement["attributes"];
-    elements: [{
-        type: "text";
-        text: string;
-    }] | [];
-};
-export declare function addElement(xml: XMLElement, element: XMLElement): void;
-export declare function setAttribute(xml: XMLElement, attribute: string, value: string): void;
-export declare function deleteAttribute(xml: XMLElement, attribute: string): void;
-declare const XML: {
-    parse: typeof parse;
-    stringify: typeof import('xml-js').js2xml;
-    fromContent: typeof fromContent;
-    getContent: typeof getContent;
-    addElement: typeof addElement;
-    setAttribute: typeof setAttribute;
-    deleteAttribute: typeof deleteAttribute;
-};
-export default XML;
+export * from './xml-js';
+export { xml } from './schema-meta';
+export type { UserCodecOptions } from './codec';
+export { registerDefault, normalizeCodecOptions } from './codec';
+export { xmlModel, type XmlModelConstructor } from './model';
 //# sourceMappingURL=index.d.ts.map

package/dist/xml/index.js

@@ -1,57 +1,17 @@
-import XMLJS from "./xml-js.js";
-function parse(string) {
-  return XMLJS.parse(string);
-}
-const stringify = XMLJS.stringify;
-function getContent(xml) {
-  if (xml.elements?.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)}`);
-}
-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;
-}
-function addElement(xml, element) {
-  if (!xml.elements) xml.elements = [];
-  xml.elements.push(element);
-}
-function setAttribute(xml, attribute, value) {
-  if (!xml.attributes) xml.attributes = {};
-  xml.attributes[attribute] = value;
-}
-function deleteAttribute(xml, attribute) {
-  if (!xml.attributes) return;
-  delete xml.attributes[attribute];
-}
-const XML = {
-  parse,
-  stringify,
-  fromContent,
-  getContent,
-  addElement,
-  setAttribute,
-  deleteAttribute
-};
+import { XML, ZXMLCommentNode, ZXMLElementNode, ZXMLNode, ZXMLRoot, ZXMLTextNode } from "./xml-js.js";
+import { xml } from "./schema-meta.js";
+import { normalizeCodecOptions, registerDefault } from "./codec.js";
+import { xmlModel } from "./model.js";
 export {
-  addElement,
-  XML as default,
-  deleteAttribute,
-  fromContent,
-  getContent,
-  parse,
-  setAttribute,
-  stringify
+  XML,
+  ZXMLCommentNode,
+  ZXMLElementNode,
+  ZXMLNode,
+  ZXMLRoot,
+  ZXMLTextNode,
+  normalizeCodecOptions,
+  registerDefault,
+  xml,
+  xmlModel
 };
 //# sourceMappingURL=index.js.map

package/dist/xml/model.d.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { XMLElement, StringifyOptions, XMLRoot } from './xml-js';
+import { ModelConstructor } from '../model';
+import { UserCodecOptions } from './codec';
+/**
+ * Constructor type for xmlModel classes.
+ * Extends ModelConstructor with XML-specific helpers and a typed extend().
+ */
+export type XmlModelConstructor<S extends z.ZodObject<any> = z.ZodObject<any>, Inst extends z.infer<S> = z.infer<S>> = ModelConstructor<S, Inst> & {
+    /** Returns a new instance parsed from an XML string or XMLRoot. */
+    fromXML<T extends abstract new (...args: any[]) => any>(this: T, xmlInput: string | XMLRoot | XMLElement): InstanceType<T>;
+    /** Converts an instance to an XMLRoot document tree. */
+    toXML(instance: z.infer<S>): XMLRoot;
+    /** Converts an instance to an XML string. */
+    toXMLString(instance: z.infer<S>, options?: StringifyOptions): string;
+};
+export declare function xmlModel<S extends z.ZodObject<any>>(schema: S, options?: UserCodecOptions<S>): XmlModelConstructor<S>;
+//# sourceMappingURL=model.d.ts.map