@abapify/ts-xsd 0.4.1 → 0.4.4

package/dist/index.mjs

@@ -1,8 +1,812 @@
-import { _ as getAllChildElements, a as loadAndLinkSchema, b as getLocalName, c as getSubstitutes, d as SchemaTraverser, f as resolveSchemaTypes, g as parseXsd, h as buildXsd, i as linkSchema, l as resolveSchema, m as resolveImports, n as createSchemaLoader, o as loadSchema, p as linkSchemas, r as defaultLoader, s as parseSchemaContent, t as runCodegen, u as SchemaResolver, v as getAttributeValue, x as getTextContent, y as getChildElements } from "./runner-CRhT3smd.mjs";
-import { n as generateSchemaLiteral, t as generateSchemaFile } from "./generate-DnX2dJZe.mjs";
-import { n as deriveRootTypeName, r as generateInterfaces, t as defineConfig } from "./types-CtrpGRyM.mjs";
+import { _ as getLocalName, a as loadAndLinkSchema, c as getSubstitutes, d as SchemaTraverser, f as resolveSchemaTypes, g as getChildElements, h as getAttributeValue, i as linkSchema, l as resolveSchema, m as getAllChildElements, n as createSchemaLoader, o as loadSchema, p as parseXsd, r as defaultLoader, s as parseSchemaContent, t as runCodegen, u as SchemaResolver, v as getTextContent } from "./runner-DX40fZp_.mjs";
+import { n as generateSchemaLiteral, t as generateSchemaFile } from "./generate-BsE7j6DV.mjs";
+import { n as deriveRootTypeName, r as generateInterfaces, t as defineConfig } from "./types-DqeG5gw1.mjs";
 import { DOMImplementation, DOMParser, XMLSerializer } from "@xmldom/xmldom";
 
+//#region src/xsd/build.ts
+/**
+* Build an XSD string from a typed Schema object
+*/
+function buildXsd(schema, options = {}) {
+	const prefix = options.prefix ?? "xs";
+	const pretty = options.pretty ?? true;
+	const ctx = {
+		prefix,
+		pretty,
+		indent: options.indent ?? "  ",
+		level: 0
+	};
+	const lines = [];
+	lines.push("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
+	lines.push(buildSchema(schema, ctx));
+	return lines.join(pretty ? "\n" : "");
+}
+function buildSchema(schema, ctx) {
+	const attrs = [];
+	if (schema.$xmlns) for (const [prefix, uri] of Object.entries(schema.$xmlns)) if (prefix === "") attrs.push(`xmlns="${uri}"`);
+	else attrs.push(`xmlns:${prefix}="${uri}"`);
+	addAttr(attrs, "id", schema.id);
+	addAttr(attrs, "targetNamespace", schema.targetNamespace);
+	addAttr(attrs, "version", schema.version);
+	addAttr(attrs, "finalDefault", schema.finalDefault);
+	addAttr(attrs, "blockDefault", schema.blockDefault);
+	addAttr(attrs, "attributeFormDefault", schema.attributeFormDefault);
+	addAttr(attrs, "elementFormDefault", schema.elementFormDefault);
+	addAttr(attrs, "defaultAttributes", schema.defaultAttributes);
+	addAttr(attrs, "xpathDefaultNamespace", schema.xpathDefaultNamespace);
+	addAttr(attrs, "xml:lang", schema["xml:lang"]);
+	const children = [];
+	const childCtx = {
+		...ctx,
+		level: ctx.level + 1
+	};
+	if (schema.annotation) for (const ann of schema.annotation) children.push(buildAnnotation(ann, childCtx));
+	if (schema.include) for (const inc of schema.include) children.push(buildInclude(inc, childCtx));
+	if (schema.import) for (const imp of schema.import) children.push(buildImport(imp, childCtx));
+	if (schema.redefine) for (const red of schema.redefine) children.push(buildRedefine(red, childCtx));
+	if (schema.override) for (const ovr of schema.override) children.push(buildOverride(ovr, childCtx));
+	if (schema.defaultOpenContent) children.push(buildDefaultOpenContent(schema.defaultOpenContent, childCtx));
+	if (schema.simpleType && Array.isArray(schema.simpleType)) for (const st of schema.simpleType) children.push(buildTopLevelSimpleType(st, childCtx));
+	if (schema.complexType && Array.isArray(schema.complexType)) for (const ct of schema.complexType) children.push(buildTopLevelComplexType(ct, childCtx));
+	if (schema.group) for (const grp of schema.group) children.push(buildNamedGroup(grp, childCtx));
+	if (schema.attributeGroup) for (const ag of schema.attributeGroup) children.push(buildNamedAttributeGroup(ag, childCtx));
+	if (schema.element) for (const el of schema.element) children.push(buildTopLevelElement(el, childCtx));
+	if (schema.attribute) for (const attr of schema.attribute) children.push(buildTopLevelAttribute(attr, childCtx));
+	if (schema.notation) for (const not of schema.notation) children.push(buildNotation(not, childCtx));
+	return buildElement$1(`${ctx.prefix}:schema`, attrs, children, ctx);
+}
+function buildAnnotation(ann, ctx) {
+	const attrs = [];
+	addAttr(attrs, "id", ann.id);
+	const children = [];
+	const childCtx = {
+		...ctx,
+		level: ctx.level + 1
+	};
+	if (ann.appinfo) for (const ai of ann.appinfo) children.push(buildAppinfo(ai, childCtx));
+	if (ann.documentation) for (const doc of ann.documentation) children.push(buildDocumentation(doc, childCtx));
+	return buildElement$1(`${ctx.prefix}:annotation`, attrs, children, ctx);
+}
+function buildDocumentation(doc, ctx) {
+	const attrs = [];
+	addAttr(attrs, "source", doc.source);
+	addAttr(attrs, "xml:lang", doc["xml:lang"]);
+	if (doc._text) return buildElementWithText(`${ctx.prefix}:documentation`, attrs, doc._text, ctx);
+	return buildElement$1(`${ctx.prefix}:documentation`, attrs, [], ctx);
+}
+function buildAppinfo(ai, ctx) {
+	const attrs = [];
+	addAttr(attrs, "source", ai.source);
+	if (ai._text) return buildElementWithText(`${ctx.prefix}:appinfo`, attrs, ai._text, ctx);
+	return buildElement$1(`${ctx.prefix}:appinfo`, attrs, [], ctx);
+}
+function buildInclude(inc, ctx) {
+	const attrs = [];
+	addAttr(attrs, "id", inc.id);
+	addAttr(attrs, "schemaLocation", inc.schemaLocation);
+	const children = [];
+	if (inc.annotation) children.push(buildAnnotation(inc.annotation, {
+		...ctx,
+		level: ctx.level + 1
+	}));
+	return buildElement$1(`${ctx.prefix}:include`, attrs, children, ctx);
+}
+function buildImport(imp, ctx) {
+	const attrs = [];
+	addAttr(attrs, "id", imp.id);
+	addAttr(attrs, "namespace", imp.namespace);
+	addAttr(attrs, "schemaLocation", imp.schemaLocation);
+	const children = [];
+	if (imp.annotation) children.push(buildAnnotation(imp.annotation, {
+		...ctx,
+		level: ctx.level + 1
+	}));
+	return buildElement$1(`${ctx.prefix}:import`, attrs, children, ctx);
+}
+function buildRedefine(red, ctx) {
+	const attrs = [];
+	addAttr(attrs, "id", red.id);
+	addAttr(attrs, "schemaLocation", red.schemaLocation);
+	const children = [];
+	const childCtx = {
+		...ctx,
+		level: ctx.level + 1
+	};
+	if (red.annotation) for (const ann of red.annotation) children.push(buildAnnotation(ann, childCtx));
+	if (red.simpleType) for (const st of red.simpleType) children.push(buildTopLevelSimpleType(st, childCtx));
+	if (red.complexType) for (const ct of red.complexType) children.push(buildTopLevelComplexType(ct, childCtx));
+	if (red.group) for (const grp of red.group) children.push(buildNamedGroup(grp, childCtx));
+	if (red.attributeGroup) for (const ag of red.attributeGroup) children.push(buildNamedAttributeGroup(ag, childCtx));
+	return buildElement$1(`${ctx.prefix}:redefine`, attrs, children, ctx);
+}
+function buildOverride(ovr, ctx) {
+	const attrs = [];
+	addAttr(attrs, "id", ovr.id);
+	addAttr(attrs, "schemaLocation", ovr.schemaLocation);
+	const children = [];
+	const childCtx = {
+		...ctx,
+		level: ctx.level + 1
+	};
+	if (ovr.annotation) for (const ann of ovr.annotation) children.push(buildAnnotation(ann, childCtx));
+	if (ovr.simpleType) for (const st of ovr.simpleType) children.push(buildTopLevelSimpleType(st, childCtx));
+	if (ovr.complexType) for (const ct of ovr.complexType) children.push(buildTopLevelComplexType(ct, childCtx));
+	if (ovr.group) for (const grp of ovr.group) children.push(buildNamedGroup(grp, childCtx));
+	if (ovr.attributeGroup) for (const ag of ovr.attributeGroup) children.push(buildNamedAttributeGroup(ag, childCtx));
+	if (ovr.element) for (const el of ovr.element) children.push(buildTopLevelElement(el, childCtx));
+	if (ovr.attribute) for (const attr of ovr.attribute) children.push(buildTopLevelAttribute(attr, childCtx));
+	if (ovr.notation) for (const not of ovr.notation) children.push(buildNotation(not, childCtx));
+	return buildElement$1(`${ctx.prefix}:override`, attrs, children, ctx);
+}
+function buildTopLevelElement(el, ctx) {
+	const attrs = [];
+	addAttr(attrs, "id", el.id);
+	addAttr(attrs, "name", el.name);
+	addAttr(attrs, "type", el.type);
+	addAttr(attrs, "substitutionGroup", el.substitutionGroup);
+	addAttr(attrs, "default", el.default);
+	addAttr(attrs, "fixed", el.fixed);
+	addBoolAttr(attrs, "nillable", el.nillable);
+	addBoolAttr(attrs, "abstract", el.abstract);
+	addAttr(attrs, "final", el.final);
+	addAttr(attrs, "block", el.block);
+	const children = [];
+	const childCtx = {
+		...ctx,
+		level: ctx.level + 1
+	};
+	if (el.annotation) children.push(buildAnnotation(el.annotation, childCtx));
+	if (el.simpleType) children.push(buildLocalSimpleType(el.simpleType, childCtx));
+	if (el.complexType) children.push(buildLocalComplexType(el.complexType, childCtx));
+	if (el.alternative) for (const alt of el.alternative) children.push(buildAlternative(alt, childCtx));
+	if (el.unique) for (const u of el.unique) children.push(buildUnique(u, childCtx));
+	if (el.key) for (const k of el.key) children.push(buildKey(k, childCtx));
+	if (el.keyref) for (const kr of el.keyref) children.push(buildKeyref(kr, childCtx));
+	return buildElement$1(`${ctx.prefix}:element`, attrs, children, ctx);
+}
+function buildLocalElement(el, ctx) {
+	const attrs = [];
+	addAttr(attrs, "id", el.id);
+	addAttr(attrs, "name", el.name);
+	addAttr(attrs, "ref", el.ref);
+	addAttr(attrs, "type", el.type);
+	addOccursAttr(attrs, "minOccurs", el.minOccurs);
+	addOccursAttr(attrs, "maxOccurs", el.maxOccurs);
+	addAttr(attrs, "default", el.default);
+	addAttr(attrs, "fixed", el.fixed);
+	addBoolAttr(attrs, "nillable", el.nillable);
+	addAttr(attrs, "block", el.block);
+	addAttr(attrs, "form", el.form);
+	addAttr(attrs, "targetNamespace", el.targetNamespace);
+	const children = [];
+	const childCtx = {
+		...ctx,
+		level: ctx.level + 1
+	};
+	if (el.annotation) children.push(buildAnnotation(el.annotation, childCtx));
+	if (el.simpleType) children.push(buildLocalSimpleType(el.simpleType, childCtx));
+	if (el.complexType) children.push(buildLocalComplexType(el.complexType, childCtx));
+	if (el.alternative) for (const alt of el.alternative) children.push(buildAlternative(alt, childCtx));
+	if (el.unique) for (const u of el.unique) children.push(buildUnique(u, childCtx));
+	if (el.key) for (const k of el.key) children.push(buildKey(k, childCtx));
+	if (el.keyref) for (const kr of el.keyref) children.push(buildKeyref(kr, childCtx));
+	return buildElement$1(`${ctx.prefix}:element`, attrs, children, ctx);
+}
+function buildTopLevelAttribute(attr, ctx) {
+	const attrs = [];
+	addAttr(attrs, "id", attr.id);
+	addAttr(attrs, "name", attr.name);
+	addAttr(attrs, "type", attr.type);
+	addAttr(attrs, "default", attr.default);
+	addAttr(attrs, "fixed", attr.fixed);
+	addBoolAttr(attrs, "inheritable", attr.inheritable);
+	const children = [];
+	const childCtx = {
+		...ctx,
+		level: ctx.level + 1
+	};
+	if (attr.annotation) children.push(buildAnnotation(attr.annotation, childCtx));
+	if (attr.simpleType) children.push(buildLocalSimpleType(attr.simpleType, childCtx));
+	return buildElement$1(`${ctx.prefix}:attribute`, attrs, children, ctx);
+}
+function buildLocalAttribute(attr, ctx) {
+	const attrs = [];
+	addAttr(attrs, "id", attr.id);
+	addAttr(attrs, "name", attr.name);
+	addAttr(attrs, "ref", attr.ref);
+	addAttr(attrs, "type", attr.type);
+	addAttr(attrs, "use", attr.use);
+	addAttr(attrs, "default", attr.default);
+	addAttr(attrs, "fixed", attr.fixed);
+	addAttr(attrs, "form", attr.form);
+	addAttr(attrs, "targetNamespace", attr.targetNamespace);
+	addBoolAttr(attrs, "inheritable", attr.inheritable);
+	const children = [];
+	const childCtx = {
+		...ctx,
+		level: ctx.level + 1
+	};
+	if (attr.annotation) children.push(buildAnnotation(attr.annotation, childCtx));
+	if (attr.simpleType) children.push(buildLocalSimpleType(attr.simpleType, childCtx));
+	return buildElement$1(`${ctx.prefix}:attribute`, attrs, children, ctx);
+}
+function buildTopLevelComplexType(ct, ctx) {
+	const attrs = [];
+	addAttr(attrs, "id", ct.id);
+	addAttr(attrs, "name", ct.name);
+	addBoolAttr(attrs, "mixed", ct.mixed);
+	addBoolAttr(attrs, "abstract", ct.abstract);
+	addAttr(attrs, "final", ct.final);
+	addAttr(attrs, "block", ct.block);
+	addBoolAttr(attrs, "defaultAttributesApply", ct.defaultAttributesApply);
+	return buildComplexTypeContent(ct, attrs, ctx);
+}
+function buildLocalComplexType(ct, ctx) {
+	const attrs = [];
+	addAttr(attrs, "id", ct.id);
+	addBoolAttr(attrs, "mixed", ct.mixed);
+	return buildComplexTypeContent(ct, attrs, ctx);
+}
+function buildComplexTypeContent(ct, attrs, ctx) {
+	const children = [];
+	const childCtx = {
+		...ctx,
+		level: ctx.level + 1
+	};
+	if (ct.annotation) children.push(buildAnnotation(ct.annotation, childCtx));
+	if (ct.simpleContent) children.push(buildSimpleContent(ct.simpleContent, childCtx));
+	else if (ct.complexContent) children.push(buildComplexContent(ct.complexContent, childCtx));
+	else {
+		if (ct.openContent) children.push(buildOpenContent(ct.openContent, childCtx));
+		if (ct.group) children.push(buildGroupRef(ct.group, childCtx));
+		if (ct.all) children.push(buildAll(ct.all, childCtx));
+		if (ct.choice) children.push(buildExplicitGroup(ct.choice, "choice", childCtx));
+		if (ct.sequence) children.push(buildExplicitGroup(ct.sequence, "sequence", childCtx));
+		if (ct.attribute) for (const attr of ct.attribute) children.push(buildLocalAttribute(attr, childCtx));
+		if (ct.attributeGroup) for (const ag of ct.attributeGroup) children.push(buildAttributeGroupRef(ag, childCtx));
+		if (ct.anyAttribute) children.push(buildAnyAttribute(ct.anyAttribute, childCtx));
+		if (ct.assert) for (const a of ct.assert) children.push(buildAssertion(a, childCtx));
+	}
+	return buildElement$1(`${ctx.prefix}:complexType`, attrs, children, ctx);
+}
+function buildTopLevelSimpleType(st, ctx) {
+	const attrs = [];
+	addAttr(attrs, "id", st.id);
+	addAttr(attrs, "name", st.name);
+	addAttr(attrs, "final", st.final);
+	return buildSimpleTypeContent(st, attrs, ctx);
+}
+function buildLocalSimpleType(st, ctx) {
+	const attrs = [];
+	addAttr(attrs, "id", st.id);
+	return buildSimpleTypeContent(st, attrs, ctx);
+}
+function buildSimpleTypeContent(st, attrs, ctx) {
+	const children = [];
+	const childCtx = {
+		...ctx,
+		level: ctx.level + 1
+	};
+	if (st.annotation) children.push(buildAnnotation(st.annotation, childCtx));
+	if (st.restriction) children.push(buildSimpleTypeRestriction(st.restriction, childCtx));
+	else if (st.list) children.push(buildList(st.list, childCtx));
+	else if (st.union) children.push(buildUnion(st.union, childCtx));
+	return buildElement$1(`${ctx.prefix}:simpleType`, attrs, children, ctx);
+}
+function buildSimpleTypeRestriction(r, ctx) {
+	const attrs = [];
+	addAttr(attrs, "id", r.id);
+	addAttr(attrs, "base", r.base);
+	const children = [];
+	const childCtx = {
+		...ctx,
+		level: ctx.level + 1
+	};
+	if (r.annotation) children.push(buildAnnotation(r.annotation, childCtx));
+	if (r.simpleType) children.push(buildLocalSimpleType(r.simpleType, childCtx));
+	buildFacets(r, children, childCtx);
+	return buildElement$1(`${ctx.prefix}:restriction`, attrs, children, ctx);
+}
+function buildFacets(r, children, ctx) {
+	if (r.minExclusive) for (const f of r.minExclusive) children.push(buildFacet(f, "minExclusive", ctx));
+	if (r.minInclusive) for (const f of r.minInclusive) children.push(buildFacet(f, "minInclusive", ctx));
+	if (r.maxExclusive) for (const f of r.maxExclusive) children.push(buildFacet(f, "maxExclusive", ctx));
+	if (r.maxInclusive) for (const f of r.maxInclusive) children.push(buildFacet(f, "maxInclusive", ctx));
+	if (r.totalDigits) for (const f of r.totalDigits) children.push(buildFacet(f, "totalDigits", ctx));
+	if (r.fractionDigits) for (const f of r.fractionDigits) children.push(buildFacet(f, "fractionDigits", ctx));
+	if (r.length) for (const f of r.length) children.push(buildFacet(f, "length", ctx));
+	if (r.minLength) for (const f of r.minLength) children.push(buildFacet(f, "minLength", ctx));
+	if (r.maxLength) for (const f of r.maxLength) children.push(buildFacet(f, "maxLength", ctx));
+	if (r.enumeration) for (const f of r.enumeration) children.push(buildFacet(f, "enumeration", ctx));
+	if (r.whiteSpace) for (const f of r.whiteSpace) children.push(buildFacet(f, "whiteSpace", ctx));
+	if (r.pattern) for (const p of r.pattern) children.push(buildPattern(p, ctx));
+	if (r.assertion) for (const a of r.assertion) children.push(buildAssertion(a, ctx));
+	if (r.explicitTimezone) for (const f of r.explicitTimezone) children.push(buildFacet(f, "explicitTimezone", ctx));
+}
+function buildFacet(f, name, ctx) {
+	const attrs = [];
+	addAttr(attrs, "id", f.id);
+	addAttr(attrs, "value", f.value);
+	addBoolAttr(attrs, "fixed", f.fixed);
+	const children = [];
+	if (f.annotation) children.push(buildAnnotation(f.annotation, {
+		...ctx,
+		level: ctx.level + 1
+	}));
+	return buildElement$1(`${ctx.prefix}:${name}`, attrs, children, ctx);
+}
+function buildPattern(p, ctx) {
+	const attrs = [];
+	addAttr(attrs, "id", p.id);
+	addAttr(attrs, "value", p.value);
+	const children = [];
+	if (p.annotation) children.push(buildAnnotation(p.annotation, {
+		...ctx,
+		level: ctx.level + 1
+	}));
+	return buildElement$1(`${ctx.prefix}:pattern`, attrs, children, ctx);
+}
+function buildList(l, ctx) {
+	const attrs = [];
+	addAttr(attrs, "id", l.id);
+	addAttr(attrs, "itemType", l.itemType);
+	const children = [];
+	const childCtx = {
+		...ctx,
+		level: ctx.level + 1
+	};
+	if (l.annotation) children.push(buildAnnotation(l.annotation, childCtx));
+	if (l.simpleType) children.push(buildLocalSimpleType(l.simpleType, childCtx));
+	return buildElement$1(`${ctx.prefix}:list`, attrs, children, ctx);
+}
+function buildUnion(u, ctx) {
+	const attrs = [];
+	addAttr(attrs, "id", u.id);
+	addAttr(attrs, "memberTypes", u.memberTypes);
+	const children = [];
+	const childCtx = {
+		...ctx,
+		level: ctx.level + 1
+	};
+	if (u.annotation) children.push(buildAnnotation(u.annotation, childCtx));
+	if (u.simpleType) for (const st of u.simpleType) children.push(buildLocalSimpleType(st, childCtx));
+	return buildElement$1(`${ctx.prefix}:union`, attrs, children, ctx);
+}
+function buildComplexContent(cc, ctx) {
+	const attrs = [];
+	addAttr(attrs, "id", cc.id);
+	addBoolAttr(attrs, "mixed", cc.mixed);
+	const children = [];
+	const childCtx = {
+		...ctx,
+		level: ctx.level + 1
+	};
+	if (cc.annotation) children.push(buildAnnotation(cc.annotation, childCtx));
+	if (cc.restriction) children.push(buildComplexContentRestriction(cc.restriction, childCtx));
+	else if (cc.extension) children.push(buildComplexContentExtension(cc.extension, childCtx));
+	return buildElement$1(`${ctx.prefix}:complexContent`, attrs, children, ctx);
+}
+function buildSimpleContent(sc, ctx) {
+	const attrs = [];
+	addAttr(attrs, "id", sc.id);
+	const children = [];
+	const childCtx = {
+		...ctx,
+		level: ctx.level + 1
+	};
+	if (sc.annotation) children.push(buildAnnotation(sc.annotation, childCtx));
+	if (sc.restriction) children.push(buildSimpleContentRestriction(sc.restriction, childCtx));
+	else if (sc.extension) children.push(buildSimpleContentExtension(sc.extension, childCtx));
+	return buildElement$1(`${ctx.prefix}:simpleContent`, attrs, children, ctx);
+}
+function buildComplexContentRestriction(r, ctx) {
+	const attrs = [];
+	addAttr(attrs, "id", r.id);
+	addAttr(attrs, "base", r.base);
+	const children = [];
+	const childCtx = {
+		...ctx,
+		level: ctx.level + 1
+	};
+	if (r.annotation) children.push(buildAnnotation(r.annotation, childCtx));
+	if (r.openContent) children.push(buildOpenContent(r.openContent, childCtx));
+	if (r.group) children.push(buildGroupRef(r.group, childCtx));
+	if (r.all) children.push(buildAll(r.all, childCtx));
+	if (r.choice) children.push(buildExplicitGroup(r.choice, "choice", childCtx));
+	if (r.sequence) children.push(buildExplicitGroup(r.sequence, "sequence", childCtx));
+	if (r.attribute) for (const attr of r.attribute) children.push(buildLocalAttribute(attr, childCtx));
+	if (r.attributeGroup) for (const ag of r.attributeGroup) children.push(buildAttributeGroupRef(ag, childCtx));
+	if (r.anyAttribute) children.push(buildAnyAttribute(r.anyAttribute, childCtx));
+	if (r.assert) for (const a of r.assert) children.push(buildAssertion(a, childCtx));
+	return buildElement$1(`${ctx.prefix}:restriction`, attrs, children, ctx);
+}
+function buildComplexContentExtension(e, ctx) {
+	const attrs = [];
+	addAttr(attrs, "id", e.id);
+	addAttr(attrs, "base", e.base);
+	const children = [];
+	const childCtx = {
+		...ctx,
+		level: ctx.level + 1
+	};
+	if (e.annotation) children.push(buildAnnotation(e.annotation, childCtx));
+	if (e.openContent) children.push(buildOpenContent(e.openContent, childCtx));
+	if (e.group) children.push(buildGroupRef(e.group, childCtx));
+	if (e.all) children.push(buildAll(e.all, childCtx));
+	if (e.choice) children.push(buildExplicitGroup(e.choice, "choice", childCtx));
+	if (e.sequence) children.push(buildExplicitGroup(e.sequence, "sequence", childCtx));
+	if (e.attribute) for (const attr of e.attribute) children.push(buildLocalAttribute(attr, childCtx));
+	if (e.attributeGroup) for (const ag of e.attributeGroup) children.push(buildAttributeGroupRef(ag, childCtx));
+	if (e.anyAttribute) children.push(buildAnyAttribute(e.anyAttribute, childCtx));
+	if (e.assert) for (const a of e.assert) children.push(buildAssertion(a, childCtx));
+	return buildElement$1(`${ctx.prefix}:extension`, attrs, children, ctx);
+}
+function buildSimpleContentRestriction(r, ctx) {
+	const attrs = [];
+	addAttr(attrs, "id", r.id);
+	addAttr(attrs, "base", r.base);
+	const children = [];
+	const childCtx = {
+		...ctx,
+		level: ctx.level + 1
+	};
+	if (r.annotation) children.push(buildAnnotation(r.annotation, childCtx));
+	if (r.simpleType) children.push(buildLocalSimpleType(r.simpleType, childCtx));
+	buildFacets(r, children, childCtx);
+	if (r.attribute) for (const attr of r.attribute) children.push(buildLocalAttribute(attr, childCtx));
+	if (r.attributeGroup) for (const ag of r.attributeGroup) children.push(buildAttributeGroupRef(ag, childCtx));
+	if (r.anyAttribute) children.push(buildAnyAttribute(r.anyAttribute, childCtx));
+	if (r.assert) for (const a of r.assert) children.push(buildAssertion(a, childCtx));
+	return buildElement$1(`${ctx.prefix}:restriction`, attrs, children, ctx);
+}
+function buildSimpleContentExtension(e, ctx) {
+	const attrs = [];
+	addAttr(attrs, "id", e.id);
+	addAttr(attrs, "base", e.base);
+	const children = [];
+	const childCtx = {
+		...ctx,
+		level: ctx.level + 1
+	};
+	if (e.annotation) children.push(buildAnnotation(e.annotation, childCtx));
+	if (e.attribute) for (const attr of e.attribute) children.push(buildLocalAttribute(attr, childCtx));
+	if (e.attributeGroup) for (const ag of e.attributeGroup) children.push(buildAttributeGroupRef(ag, childCtx));
+	if (e.anyAttribute) children.push(buildAnyAttribute(e.anyAttribute, childCtx));
+	if (e.assert) for (const a of e.assert) children.push(buildAssertion(a, childCtx));
+	return buildElement$1(`${ctx.prefix}:extension`, attrs, children, ctx);
+}
+function buildExplicitGroup(g, name, ctx) {
+	const attrs = [];
+	addAttr(attrs, "id", g.id);
+	addOccursAttr(attrs, "minOccurs", g.minOccurs);
+	addOccursAttr(attrs, "maxOccurs", g.maxOccurs);
+	const children = [];
+	const childCtx = {
+		...ctx,
+		level: ctx.level + 1
+	};
+	if (g.annotation) children.push(buildAnnotation(g.annotation, childCtx));
+	if (g.element) for (const el of g.element) children.push(buildLocalElement(el, childCtx));
+	if (g.group) for (const grp of g.group) children.push(buildGroupRef(grp, childCtx));
+	if (g.choice) for (const c of g.choice) children.push(buildExplicitGroup(c, "choice", childCtx));
+	if (g.sequence) for (const s of g.sequence) children.push(buildExplicitGroup(s, "sequence", childCtx));
+	if (g.any) for (const a of g.any) children.push(buildAny(a, childCtx));
+	return buildElement$1(`${ctx.prefix}:${name}`, attrs, children, ctx);
+}
+function buildAll(a, ctx) {
+	const attrs = [];
+	addAttr(attrs, "id", a.id);
+	addOccursAttr(attrs, "minOccurs", a.minOccurs);
+	addOccursAttr(attrs, "maxOccurs", a.maxOccurs);
+	const children = [];
+	const childCtx = {
+		...ctx,
+		level: ctx.level + 1
+	};
+	if (a.annotation) children.push(buildAnnotation(a.annotation, childCtx));
+	if (a.element) for (const el of a.element) children.push(buildLocalElement(el, childCtx));
+	if (a.any) for (const any of a.any) children.push(buildAny(any, childCtx));
+	if (a.group) for (const grp of a.group) children.push(buildGroupRef(grp, childCtx));
+	return buildElement$1(`${ctx.prefix}:all`, attrs, children, ctx);
+}
+function buildNamedGroup(g, ctx) {
+	const attrs = [];
+	addAttr(attrs, "id", g.id);
+	addAttr(attrs, "name", g.name);
+	const children = [];
+	const childCtx = {
+		...ctx,
+		level: ctx.level + 1
+	};
+	if (g.annotation) children.push(buildAnnotation(g.annotation, childCtx));
+	if (g.all) children.push(buildAll(g.all, childCtx));
+	if (g.choice) children.push(buildExplicitGroup(g.choice, "choice", childCtx));
+	if (g.sequence) children.push(buildExplicitGroup(g.sequence, "sequence", childCtx));
+	return buildElement$1(`${ctx.prefix}:group`, attrs, children, ctx);
+}
+function buildGroupRef(g, ctx) {
+	const attrs = [];
+	addAttr(attrs, "id", g.id);
+	addAttr(attrs, "ref", g.ref);
+	addOccursAttr(attrs, "minOccurs", g.minOccurs);
+	addOccursAttr(attrs, "maxOccurs", g.maxOccurs);
+	const children = [];
+	if (g.annotation) children.push(buildAnnotation(g.annotation, {
+		...ctx,
+		level: ctx.level + 1
+	}));
+	return buildElement$1(`${ctx.prefix}:group`, attrs, children, ctx);
+}
+function buildNamedAttributeGroup(ag, ctx) {
+	const attrs = [];
+	addAttr(attrs, "id", ag.id);
+	addAttr(attrs, "name", ag.name);
+	const children = [];
+	const childCtx = {
+		...ctx,
+		level: ctx.level + 1
+	};
+	if (ag.annotation) children.push(buildAnnotation(ag.annotation, childCtx));
+	if (ag.attribute) for (const attr of ag.attribute) children.push(buildLocalAttribute(attr, childCtx));
+	if (ag.attributeGroup) for (const agr of ag.attributeGroup) children.push(buildAttributeGroupRef(agr, childCtx));
+	if (ag.anyAttribute) children.push(buildAnyAttribute(ag.anyAttribute, childCtx));
+	return buildElement$1(`${ctx.prefix}:attributeGroup`, attrs, children, ctx);
+}
+function buildAttributeGroupRef(ag, ctx) {
+	const attrs = [];
+	addAttr(attrs, "id", ag.id);
+	addAttr(attrs, "ref", ag.ref);
+	const children = [];
+	if (ag.annotation) children.push(buildAnnotation(ag.annotation, {
+		...ctx,
+		level: ctx.level + 1
+	}));
+	return buildElement$1(`${ctx.prefix}:attributeGroup`, attrs, children, ctx);
+}
+function buildAny(a, ctx) {
+	const attrs = [];
+	addAttr(attrs, "id", a.id);
+	addOccursAttr(attrs, "minOccurs", a.minOccurs);
+	addOccursAttr(attrs, "maxOccurs", a.maxOccurs);
+	addAttr(attrs, "namespace", a.namespace);
+	addAttr(attrs, "processContents", a.processContents);
+	addAttr(attrs, "notNamespace", a.notNamespace);
+	addAttr(attrs, "notQName", a.notQName);
+	const children = [];
+	if (a.annotation) children.push(buildAnnotation(a.annotation, {
+		...ctx,
+		level: ctx.level + 1
+	}));
+	return buildElement$1(`${ctx.prefix}:any`, attrs, children, ctx);
+}
+function buildAnyAttribute(aa, ctx) {
+	const attrs = [];
+	addAttr(attrs, "id", aa.id);
+	addAttr(attrs, "namespace", aa.namespace);
+	addAttr(attrs, "processContents", aa.processContents);
+	addAttr(attrs, "notNamespace", aa.notNamespace);
+	addAttr(attrs, "notQName", aa.notQName);
+	const children = [];
+	if (aa.annotation) children.push(buildAnnotation(aa.annotation, {
+		...ctx,
+		level: ctx.level + 1
+	}));
+	return buildElement$1(`${ctx.prefix}:anyAttribute`, attrs, children, ctx);
+}
+function buildUnique(u, ctx) {
+	const attrs = [];
+	addAttr(attrs, "id", u.id);
+	addAttr(attrs, "name", u.name);
+	addAttr(attrs, "ref", u.ref);
+	const children = [];
+	const childCtx = {
+		...ctx,
+		level: ctx.level + 1
+	};
+	if (u.annotation) children.push(buildAnnotation(u.annotation, childCtx));
+	if (u.selector) children.push(buildSelector(u.selector, childCtx));
+	if (u.field) for (const f of u.field) children.push(buildField$1(f, childCtx));
+	return buildElement$1(`${ctx.prefix}:unique`, attrs, children, ctx);
+}
+function buildKey(k, ctx) {
+	const attrs = [];
+	addAttr(attrs, "id", k.id);
+	addAttr(attrs, "name", k.name);
+	addAttr(attrs, "ref", k.ref);
+	const children = [];
+	const childCtx = {
+		...ctx,
+		level: ctx.level + 1
+	};
+	if (k.annotation) children.push(buildAnnotation(k.annotation, childCtx));
+	if (k.selector) children.push(buildSelector(k.selector, childCtx));
+	if (k.field) for (const f of k.field) children.push(buildField$1(f, childCtx));
+	return buildElement$1(`${ctx.prefix}:key`, attrs, children, ctx);
+}
+function buildKeyref(kr, ctx) {
+	const attrs = [];
+	addAttr(attrs, "id", kr.id);
+	addAttr(attrs, "name", kr.name);
+	addAttr(attrs, "ref", kr.ref);
+	addAttr(attrs, "refer", kr.refer);
+	const children = [];
+	const childCtx = {
+		...ctx,
+		level: ctx.level + 1
+	};
+	if (kr.annotation) children.push(buildAnnotation(kr.annotation, childCtx));
+	if (kr.selector) children.push(buildSelector(kr.selector, childCtx));
+	if (kr.field) for (const f of kr.field) children.push(buildField$1(f, childCtx));
+	return buildElement$1(`${ctx.prefix}:keyref`, attrs, children, ctx);
+}
+function buildSelector(s, ctx) {
+	const attrs = [];
+	addAttr(attrs, "id", s.id);
+	addAttr(attrs, "xpath", s.xpath);
+	addAttr(attrs, "xpathDefaultNamespace", s.xpathDefaultNamespace);
+	const children = [];
+	if (s.annotation) children.push(buildAnnotation(s.annotation, {
+		...ctx,
+		level: ctx.level + 1
+	}));
+	return buildElement$1(`${ctx.prefix}:selector`, attrs, children, ctx);
+}
+function buildField$1(f, ctx) {
+	const attrs = [];
+	addAttr(attrs, "id", f.id);
+	addAttr(attrs, "xpath", f.xpath);
+	addAttr(attrs, "xpathDefaultNamespace", f.xpathDefaultNamespace);
+	const children = [];
+	if (f.annotation) children.push(buildAnnotation(f.annotation, {
+		...ctx,
+		level: ctx.level + 1
+	}));
+	return buildElement$1(`${ctx.prefix}:field`, attrs, children, ctx);
+}
+function buildOpenContent(oc, ctx) {
+	const attrs = [];
+	addAttr(attrs, "id", oc.id);
+	addAttr(attrs, "mode", oc.mode);
+	const children = [];
+	const childCtx = {
+		...ctx,
+		level: ctx.level + 1
+	};
+	if (oc.annotation) children.push(buildAnnotation(oc.annotation, childCtx));
+	if (oc.any) children.push(buildAny(oc.any, childCtx));
+	return buildElement$1(`${ctx.prefix}:openContent`, attrs, children, ctx);
+}
+function buildDefaultOpenContent(doc, ctx) {
+	const attrs = [];
+	addAttr(attrs, "id", doc.id);
+	addBoolAttr(attrs, "appliesToEmpty", doc.appliesToEmpty);
+	addAttr(attrs, "mode", doc.mode);
+	const children = [];
+	const childCtx = {
+		...ctx,
+		level: ctx.level + 1
+	};
+	if (doc.annotation) children.push(buildAnnotation(doc.annotation, childCtx));
+	children.push(buildAny(doc.any, childCtx));
+	return buildElement$1(`${ctx.prefix}:defaultOpenContent`, attrs, children, ctx);
+}
+function buildAssertion(a, ctx) {
+	const attrs = [];
+	addAttr(attrs, "id", a.id);
+	addAttr(attrs, "test", a.test);
+	addAttr(attrs, "xpathDefaultNamespace", a.xpathDefaultNamespace);
+	const children = [];
+	if (a.annotation) children.push(buildAnnotation(a.annotation, {
+		...ctx,
+		level: ctx.level + 1
+	}));
+	return buildElement$1(`${ctx.prefix}:assert`, attrs, children, ctx);
+}
+function buildAlternative(alt, ctx) {
+	const attrs = [];
+	addAttr(attrs, "id", alt.id);
+	addAttr(attrs, "test", alt.test);
+	addAttr(attrs, "type", alt.type);
+	addAttr(attrs, "xpathDefaultNamespace", alt.xpathDefaultNamespace);
+	const children = [];
+	const childCtx = {
+		...ctx,
+		level: ctx.level + 1
+	};
+	if (alt.annotation) children.push(buildAnnotation(alt.annotation, childCtx));
+	if (alt.simpleType) children.push(buildLocalSimpleType(alt.simpleType, childCtx));
+	if (alt.complexType) children.push(buildLocalComplexType(alt.complexType, childCtx));
+	return buildElement$1(`${ctx.prefix}:alternative`, attrs, children, ctx);
+}
+function buildNotation(n, ctx) {
+	const attrs = [];
+	addAttr(attrs, "id", n.id);
+	addAttr(attrs, "name", n.name);
+	addAttr(attrs, "public", n.public);
+	addAttr(attrs, "system", n.system);
+	const children = [];
+	if (n.annotation) children.push(buildAnnotation(n.annotation, {
+		...ctx,
+		level: ctx.level + 1
+	}));
+	return buildElement$1(`${ctx.prefix}:notation`, attrs, children, ctx);
+}
+function addAttr(attrs, name, value) {
+	if (value !== void 0) attrs.push(`${name}="${escapeXml(value)}"`);
+}
+function addBoolAttr(attrs, name, value) {
+	if (value !== void 0) attrs.push(`${name}="${value}"`);
+}
+function addOccursAttr(attrs, name, value) {
+	if (value !== void 0) attrs.push(`${name}="${value}"`);
+}
+function escapeXml(str) {
+	return str.replaceAll(/&/g, "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&apos;");
+}
+function buildElement$1(tag, attrs, children, ctx) {
+	const indent = ctx.pretty ? ctx.indent.repeat(ctx.level) : "";
+	const attrStr = attrs.length > 0 ? " " + attrs.join(" ") : "";
+	if (children.length === 0) return `${indent}<${tag}${attrStr}/>`;
+	const nl = ctx.pretty ? "\n" : "";
+	return `${indent}<${tag}${attrStr}>${nl}${children.join(nl)}${nl}${indent}</${tag}>`;
+}
+function buildElementWithText(tag, attrs, text, ctx) {
+	return `${ctx.pretty ? ctx.indent.repeat(ctx.level) : ""}<${tag}${attrs.length > 0 ? " " + attrs.join(" ") : ""}>${escapeXml(text)}</${tag}>`;
+}
+
+//#endregion
+//#region src/xsd/helpers.ts
+/**
+* Resolve $imports for a schema by matching import schemaLocation to $filename.
+*
+* @param schema - The schema to resolve imports for
+* @param availableSchemas - Array of schemas that may be imported
+* @returns A new schema object with $imports populated
+*
+* @example
+* ```typescript
+* const orderSchema = parseXsd(orderXsd);
+* const commonSchema = { ...parseXsd(commonXsd), $filename: 'common.xsd' };
+*
+* // orderSchema has: import: [{ schemaLocation: 'common.xsd', ... }]
+* const resolved = resolveImports(orderSchema, [commonSchema]);
+* // resolved.$imports = [commonSchema]
+* ```
+*/
+function resolveImports(schema, availableSchemas) {
+	const imports = [];
+	if (schema.import) {
+		for (const imp of schema.import) if (imp.schemaLocation) {
+			const found = availableSchemas.find((s) => s.$filename === imp.schemaLocation);
+			if (found) imports.push(found);
+		}
+	}
+	return {
+		...schema,
+		$imports: imports
+	};
+}
+/**
+* Resolve $imports for multiple schemas, linking them together.
+*
+* @param schemas - Array of schemas to link together
+* @returns Array of schemas with $imports populated
+*
+* @example
+* ```typescript
+* const schemas = [
+*   { ...parseXsd(orderXsd), $filename: 'order.xsd' },
+*   { ...parseXsd(commonXsd), $filename: 'common.xsd' },
+* ];
+* const linked = linkSchemas(schemas);
+* // Each schema now has $imports resolved
+* ```
+*/
+function linkSchemas(schemas) {
+	return schemas.map((schema) => resolveImports(schema, schemas));
+}
+
+//#endregion
 //#region src/walker/index.ts
 /**
 * Walk all complexTypes in a schema and its $imports/$includes (depth-first).
@@ -22,17 +826,19 @@ import { DOMImplementation, DOMParser, XMLSerializer } from "@xmldom/xmldom";
 */
 function* walkComplexTypes(schema, options = {}) {
 	const complexTypes = schema.complexType;
-	if (complexTypes) if (Array.isArray(complexTypes)) for (const ct of complexTypes) yield {
-		ct,
-		schema
-	};
-	else for (const [name, ct] of Object.entries(complexTypes)) yield {
-		ct: {
-			...ct,
-			name
-		},
-		schema
-	};
+	if (complexTypes) {
+		if (Array.isArray(complexTypes)) for (const ct of complexTypes) yield {
+			ct,
+			schema
+		};
+		else for (const [name, ct] of Object.entries(complexTypes)) yield {
+			ct: {
+				...ct,
+				name
+			},
+			schema
+		};
+	}
 	if (schema.redefine) {
 		for (const redef of schema.redefine) if (redef.complexType) for (const ct of redef.complexType) yield {
 			ct,
@@ -53,17 +859,19 @@ function* walkComplexTypes(schema, options = {}) {
 */
 function* walkSimpleTypes(schema, options = {}) {
 	const simpleTypes = schema.simpleType;
-	if (simpleTypes) if (Array.isArray(simpleTypes)) for (const st of simpleTypes) yield {
-		st,
-		schema
-	};
-	else for (const [name, st] of Object.entries(simpleTypes)) yield {
-		st: {
-			...st,
-			name
-		},
-		schema
-	};
+	if (simpleTypes) {
+		if (Array.isArray(simpleTypes)) for (const st of simpleTypes) yield {
+			st,
+			schema
+		};
+		else for (const [name, st] of Object.entries(simpleTypes)) yield {
+			st: {
+				...st,
+				name
+			},
+			schema
+		};
+	}
 	if (schema.redefine) {
 		for (const redef of schema.redefine) if (redef.simpleType) for (const st of redef.simpleType) yield {
 			st,
@@ -357,12 +1165,51 @@ function isArray(item) {
 	if (typeof item.maxOccurs === "number") return item.maxOccurs > 1;
 	if (typeof item.maxOccurs === "string") {
 		if (item.maxOccurs === "unbounded") return true;
-		const num = parseInt(item.maxOccurs, 10);
-		return !isNaN(num) && num > 1;
+		const num = Number.parseInt(item.maxOccurs, 10);
+		return !Number.isNaN(num) && num > 1;
 	}
 	return false;
 }
 /**
+* Check whether a complexType permits wildcard child elements (xs:any).
+* Handles sequence/choice/all, nested groups, group references,
+* and complexContent extension/restriction (including base types).
+*/
+function hasWildcard(ct, schema) {
+	const seenTypes = /* @__PURE__ */ new Set();
+	const seenGroupRefs = /* @__PURE__ */ new Set();
+	const groupsHaveAny = (...groups) => groups.some(groupHasAny);
+	function namedGroupHasAny(ref) {
+		if (!ref || seenGroupRefs.has(ref)) return false;
+		seenGroupRefs.add(ref);
+		const named = findGroup(stripNsPrefix(ref), schema);
+		if (!named) return false;
+		return groupsHaveAny(named.sequence, named.choice, named.all);
+	}
+	function groupHasAny(group) {
+		if (!group) return false;
+		if (group.any && group.any.length > 0) return true;
+		if ([...group.sequence ?? [], ...group.choice ?? []].some(groupHasAny)) return true;
+		return (group.group ?? []).some((ref) => namedGroupHasAny(ref.ref));
+	}
+	function extHasAny(current) {
+		const ext = current.complexContent?.extension ?? current.complexContent?.restriction;
+		if (!ext) return false;
+		if (groupsHaveAny(ext.sequence, ext.choice, ext.all)) return true;
+		if (namedGroupHasAny(ext.group?.ref)) return true;
+		if (!ext.base) return false;
+		const baseEntry = findComplexType(stripNsPrefix(ext.base), schema);
+		return baseEntry ? visit(baseEntry.ct) : false;
+	}
+	function visit(current) {
+		if (seenTypes.has(current)) return false;
+		seenTypes.add(current);
+		if (groupsHaveAny(current.sequence, current.choice, current.all)) return true;
+		return extHasAny(current) || namedGroupHasAny(current.group?.ref);
+	}
+	return visit(ct);
+}
+/**
 * Check if an element is abstract
 */
 function isAbstractElement(element) {
@@ -488,18 +1335,8 @@ function parseElement(node, typeDef, schema, rootSchema) {
 	for (const { element, array } of walkElements(typeDef, schema)) {
 		const resolved = resolveElementInfo$1(element, schema);
 		if (!resolved) continue;
-		if (isAbstractElement$1(resolved.name, rootSchema)) {
-			const substitutes = findSubstitutingElements(resolved.name, rootSchema);
-			const allChildren = getAllChildElements(node);
-			for (const child of allChildren) {
-				const childName = getLocalName(child);
-				const substitute = substitutes.find((s) => s.element.name === childName);
-				if (substitute && substitute.element.name) {
-					const subTypeName = substitute.element.type ? stripNsPrefix(substitute.element.type) : void 0;
-					result[substitute.element.name] = parseChildValue(child, subTypeName, substitute.schema, rootSchema);
-				}
-			}
-		} else {
+		if (isAbstractElement$1(resolved.name, rootSchema)) parseSubstitutionChildren(node, resolved.name, rootSchema, result);
+		else {
 			const children = getChildElements(node, resolved.name);
 			if (array || children.length > 1) {
 				const values = children.map((child) => parseChildValue(child, resolved.typeName, schema, rootSchema));
@@ -507,6 +1344,67 @@ function parseElement(node, typeDef, schema, rootSchema) {
 			} else if (children.length === 1) result[resolved.name] = parseChildValue(children[0], resolved.typeName, schema, rootSchema);
 		}
 	}
+	if (hasWildcard(typeDef, schema)) parseWildcardChildren(node, result);
+	return result;
+}
+/**
+* Parse children that substitute for an abstract element — substitutes can
+* live in any imported schema, so lookups use the root schema.
+*/
+function parseSubstitutionChildren(node, headName, rootSchema, result) {
+	const substitutes = findSubstitutingElements(headName, rootSchema);
+	for (const child of getAllChildElements(node)) {
+		const childName = getLocalName(child);
+		const substitute = substitutes.find((s) => s.element.name === childName);
+		if (substitute && substitute.element.name) {
+			const subTypeName = substitute.element.type ? stripNsPrefix(substitute.element.type) : void 0;
+			result[substitute.element.name] = parseChildValue(child, subTypeName, substitute.schema, rootSchema);
+		}
+	}
+}
+/**
+* Collect wildcard (xs:any) children under their qualified tag names.
+* Repeated sibling names become arrays.
+*/
+function parseWildcardChildren(node, result) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const child of getAllChildElements(node)) {
+		const name = child.tagName;
+		if (result[name] !== void 0 || seen.has(name)) continue;
+		seen.add(name);
+		const same = getAllChildElements(node).filter((c) => c.tagName === name);
+		result[name] = same.length > 1 ? same.map(parseAnyValue) : parseAnyValue(child);
+	}
+}
+/**
+* Parse a wildcard (xs:any) element generically:
+* leaf elements become strings, element children become nested records,
+* repeated names become arrays. Attributes are preserved under `@name`
+* keys (including xmlns:* for namespace round-trips) and text content of
+* attributed elements under `_text`. Qualified tag names keep their
+* namespace prefixes so prefixed children round-trip faithfully.
+*/
+function parseAnyValue(node) {
+	const result = {};
+	for (let i = 0; i < node.attributes.length; i++) {
+		const attr = node.attributes[i];
+		result[`@${attr.name}`] = attr.value;
+	}
+	const children = getAllChildElements(node);
+	if (children.length === 0) {
+		if (Object.keys(result).length === 0) return getTextContent(node);
+		const text = getTextContent(node);
+		if (text) result._text = text;
+		return result;
+	}
+	for (const child of children) {
+		const name = child.tagName;
+		const value = parseAnyValue(child);
+		const existing = result[name];
+		if (existing === void 0) result[name] = value;
+		else if (Array.isArray(existing)) existing.push(value);
+		else result[name] = [existing, value];
+	}
 	return result;
 }
 /**
@@ -863,7 +1761,8 @@ function findMatchingElement(data, schema) {
 		let ctSchema = searchSchema;
 		if (element.complexType) ct = element.complexType;
 		else if (element.type) {
-			const typeEntry = findComplexType(stripNsPrefix(element.type), searchSchema);
+			const typeName = stripNsPrefix(element.type);
+			const typeEntry = findComplexType(typeName, searchSchema);
 			if (typeEntry) {
 				ct = typeEntry.ct;
 				ctSchema = typeEntry.schema;
@@ -908,8 +1807,23 @@ function findMatchingElement(data, schema) {
 * @param rootSchema - The original schema passed to build(), used for substitution group lookup
 */
 function buildElement(doc, node, data, typeDef, schema, rootSchema, prefix) {
+	const wildcard = hasWildcard(typeDef, schema);
+	const consumed = /* @__PURE__ */ new Set();
+	buildAttributes(node, data, typeDef, schema, rootSchema, consumed);
+	buildDeclaredElements(doc, node, data, typeDef, schema, rootSchema, prefix, consumed);
+	if (wildcard) for (const key of Object.keys(data)) {
+		if (consumed.has(key)) continue;
+		buildAnyField(doc, node, key, data[key]);
+	}
+}
+/**
+* Build declared attributes from the type definition (walker handles
+* inheritance). Adds each declared attribute name to `consumed`.
+*/
+function buildAttributes(node, data, typeDef, schema, rootSchema, consumed) {
 	for (const { attribute, schema: attrSchema } of walkAttributes(typeDef, schema)) {
 		if (!attribute.name) continue;
+		consumed.add(attribute.name);
 		const value = data[attribute.name];
 		if (value !== void 0 && value !== null) {
 			const attributeFormDefault = attrSchema.attributeFormDefault;
@@ -922,28 +1836,63 @@ function buildElement(doc, node, data, typeDef, schema, rootSchema, prefix) {
 			node.setAttribute(attrName, formatValue(value, attribute.type || "string"));
 		}
 	}
+}
+/**
+* Build declared child elements via the walker (handles inheritance,
+* groups, refs, substitution). Adds each declared key to `consumed`.
+*/
+function buildDeclaredElements(doc, node, data, typeDef, schema, rootSchema, prefix, consumed) {
 	for (const { element, schema: elementDefSchema } of walkElements(typeDef, schema)) {
 		if (element.ref) {
 			const refName = stripNsPrefix(element.ref);
 			const refElement = findElement(refName, elementDefSchema);
 			if (refElement && refElement.element.abstract) {
-				const substitutes = findSubstitutes$1(refName, rootSchema);
-				for (const substitute of substitutes) {
-					const subName = substitute.element.name;
-					if (!subName) continue;
-					const value = data[subName];
-					if (value !== void 0) buildField(doc, node, value, subName, substitute.element.type ? stripNsPrefix(substitute.element.type) : void 0, substitute.schema, rootSchema, prefix);
-				}
+				buildSubstituteElements(doc, node, data, refName, rootSchema, prefix, consumed);
 				continue;
 			}
 		}
 		const resolved = resolveElementInfo(element, elementDefSchema);
 		if (!resolved) continue;
+		consumed.add(resolved.dataKey);
 		const value = data[resolved.dataKey];
-		if (value !== void 0) buildFieldWithTagName(doc, node, value, resolved.tagName, resolved.typeName, resolved.inlineComplexType, resolved.elementSchema, rootSchema, prefix, resolved.form);
+		if (value != null) buildFieldWithTagName(doc, node, value, resolved.tagName, resolved.typeName, resolved.inlineComplexType, resolved.elementSchema, rootSchema, prefix, resolved.form);
 	}
 }
 /**
+* Build elements that substitute for an abstract element — substitutes can
+* live in any imported schema, so lookups use the root schema. Adds each
+* emitted key to `consumed`.
+*/
+function buildSubstituteElements(doc, node, data, refName, rootSchema, prefix, consumed) {
+	const substitutes = findSubstitutes$1(refName, rootSchema);
+	for (const substitute of substitutes) {
+		const subName = substitute.element.name;
+		if (!subName) continue;
+		consumed.add(subName);
+		const value = data[subName];
+		if (value != null) buildField(doc, node, value, subName, substitute.element.type ? stripNsPrefix(substitute.element.type) : void 0, substitute.schema, rootSchema, prefix);
+	}
+}
+/**
+* Build a wildcard (xs:any) element generically:
+* primitives become text elements, objects become nested elements,
+* arrays become repeated sibling elements.
+*/
+function buildAnyField(doc, parent, tagName, value) {
+	if (value === void 0 || value === null) return;
+	if (Array.isArray(value)) {
+		for (const item of value) buildAnyField(doc, parent, tagName, item);
+		return;
+	}
+	const el = doc.createElement(tagName);
+	if (typeof value === "object") for (const [key, nested] of Object.entries(value)) if (key.startsWith("@")) {
+		if (nested !== void 0 && nested !== null) el.setAttribute(key.slice(1), String(nested));
+	} else if (key === "_text") el.textContent = String(nested ?? "");
+	else buildAnyField(doc, el, key, nested);
+	else el.textContent = String(value);
+	parent.appendChild(el);
+}
+/**
 * Resolve element info (name and type), handling ref
 *
 * Returns:
@@ -992,7 +1941,6 @@ function resolveElementInfo(element, schema) {
 * - "unqualified" (default): local elements do NOT get namespace prefix
 */
 function buildField(doc, parent, value, elementName, typeName, schema, rootSchema, prefix) {
-	if (value === void 0 || value === null) return;
 	const nestedType = typeName ? findComplexType(typeName, schema) : void 0;
 	const usePrefix = rootSchema.elementFormDefault === "qualified" ? prefix : void 0;
 	const tagName = usePrefix ? `${usePrefix}:${elementName}` : elementName;
@@ -1024,7 +1972,6 @@ function buildField(doc, parent, value, elementName, typeName, schema, rootSchem
 * 3. Direct elements - apply elementFormDefault logic
 */
 function buildFieldWithTagName(doc, parent, value, tagName, typeName, inlineComplexType, elementSchema, rootSchema, prefix, elementForm) {
-	if (value === void 0 || value === null) return;
 	let nestedType;
 	if (inlineComplexType) nestedType = {
 		ct: inlineComplexType,
@@ -1112,5 +2059,5 @@ function typedSchema(schema) {
 }
 
 //#endregion
-export { SchemaResolver, SchemaTraverser, build as buildXml, buildXsd, createSchemaLoader, defaultLoader, defineConfig, deriveRootTypeName, findComplexType, findElement, findSimpleType, findSubstitutes, generateInterfaces, generateSchemaFile, generateSchemaLiteral, getSubstitutes, isAbstractElement, linkSchema, linkSchemas, loadAndLinkSchema, loadSchema, parseXsd as parse, parseXsd, parseSchemaContent, parse as parseXml, resolveImports, resolveSchema, resolveSchemaTypes, runCodegen, stripNsPrefix, typedSchema, walkAttributes, walkComplexTypes, walkElements, walkSimpleTypes, walkTopLevelElements };
+export { SchemaResolver, SchemaTraverser, build as buildXml, buildXsd, createSchemaLoader, defaultLoader, defineConfig, deriveRootTypeName, findComplexType, findElement, findSimpleType, findSubstitutes, generateInterfaces, generateSchemaFile, generateSchemaLiteral, getSubstitutes, hasWildcard, isAbstractElement, linkSchema, linkSchemas, loadAndLinkSchema, loadSchema, parseXsd as parse, parseXsd, parseSchemaContent, parse as parseXml, resolveImports, resolveSchema, resolveSchemaTypes, runCodegen, stripNsPrefix, typedSchema, walkAttributes, walkComplexTypes, walkElements, walkSimpleTypes, walkTopLevelElements };
 //# sourceMappingURL=index.mjs.map