@abapify/ts-xsd 0.4.0 → 0.4.3

package/dist/index.mjs

@@ -0,0 +1,1923 @@
+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-BSGqj8LM.mjs";
+import { n as generateSchemaLiteral, t as generateSchemaFile } from "./generate-Br6rW6sE.mjs";
+import { n as deriveRootTypeName, r as generateInterfaces, t as defineConfig } from "./types-Ch0GQQ5n.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).
+*
+* @param schema - Root schema to start from
+* @param options - Walk options (e.g., includesOnly to skip $imports)
+* @yields ComplexType with the schema it was found in
+*
+* @example
+* ```typescript
+* function findComplexType(name: string, schema: SchemaLike) {
+*   for (const { ct, schema: s } of walkComplexTypes(schema)) {
+*     if (ct.name === name) return { type: ct, schema: s };
+*   }
+* }
+* ```
+*/
+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 (schema.redefine) {
+		for (const redef of schema.redefine) if (redef.complexType) for (const ct of redef.complexType) yield {
+			ct,
+			schema
+		};
+	}
+	if (schema.override) {
+		for (const ovr of schema.override) if (ovr.complexType) for (const ct of ovr.complexType) yield {
+			ct,
+			schema
+		};
+	}
+	if (schema.$includes) for (const included of schema.$includes) yield* walkComplexTypes(included, options);
+	if (!options.includesOnly && schema.$imports) for (const imported of schema.$imports) yield* walkComplexTypes(imported, options);
+}
+/**
+* Walk all simpleTypes in a schema and its $imports/$includes.
+*/
+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 (schema.redefine) {
+		for (const redef of schema.redefine) if (redef.simpleType) for (const st of redef.simpleType) yield {
+			st,
+			schema
+		};
+	}
+	if (schema.override) {
+		for (const ovr of schema.override) if (ovr.simpleType) for (const st of ovr.simpleType) yield {
+			st,
+			schema
+		};
+	}
+	if (schema.$includes) for (const included of schema.$includes) yield* walkSimpleTypes(included, options);
+	if (!options.includesOnly && schema.$imports) for (const imported of schema.$imports) yield* walkSimpleTypes(imported, options);
+}
+/**
+* Walk all top-level elements in a schema and its $imports/$includes.
+*/
+function* walkTopLevelElements(schema, options = {}) {
+	if (schema.element) for (const element of schema.element) yield {
+		element,
+		schema
+	};
+	if (schema.$includes) for (const included of schema.$includes) yield* walkTopLevelElements(included, options);
+	if (!options.includesOnly && schema.$imports) for (const imported of schema.$imports) yield* walkTopLevelElements(imported, options);
+}
+/**
+* Find a complexType by name, searching schema and $imports.
+* Returns both the type AND the schema it was found in (important for inheritance).
+*/
+function findComplexType(name, schema) {
+	for (const entry of walkComplexTypes(schema)) if (entry.ct.name === name) return entry;
+}
+/**
+* Find a simpleType by name, searching schema and $imports.
+*/
+function findSimpleType(name, schema) {
+	for (const entry of walkSimpleTypes(schema)) if (entry.st.name === name) return entry;
+}
+/**
+* Find a top-level element by name, searching schema and $imports.
+*/
+function findElement(name, schema) {
+	for (const entry of walkTopLevelElements(schema)) if (entry.element.name === name) return entry;
+}
+/**
+* Walk all elements in a complexType, handling:
+* - sequence, choice, all groups
+* - Nested groups (recursive)
+* - complexContent/extension inheritance
+* - Group references
+*
+* @param ct - ComplexType to walk
+* @param schema - Schema context (for resolving base types and group refs)
+* @yields Elements with metadata (optional, array, source)
+*/
+function* walkElements(ct, schema) {
+	if (ct.complexContent?.extension) {
+		const ext = ct.complexContent.extension;
+		if (ext.base) {
+			const baseEntry = findComplexType(stripNsPrefix(ext.base), schema);
+			if (baseEntry) yield* walkElements(baseEntry.ct, baseEntry.schema);
+		}
+		yield* walkGroup(ext.sequence, "sequence", schema);
+		yield* walkGroup(ext.choice, "choice", schema);
+		yield* walkGroup(ext.all, "all", schema);
+		if (ext.group?.ref) yield* walkGroupRef(ext.group.ref, schema);
+		return;
+	}
+	if (ct.complexContent?.restriction) {
+		const rest = ct.complexContent.restriction;
+		yield* walkGroup(rest.sequence, "sequence", schema);
+		yield* walkGroup(rest.choice, "choice", schema);
+		yield* walkGroup(rest.all, "all", schema);
+		if (rest.group?.ref) yield* walkGroupRef(rest.group.ref, schema);
+		return;
+	}
+	yield* walkGroup(ct.sequence, "sequence", schema);
+	yield* walkGroup(ct.choice, "choice", schema);
+	yield* walkGroup(ct.all, "all", schema);
+	if (ct.group?.ref) yield* walkGroupRef(ct.group.ref, schema);
+}
+/**
+* Walk elements in a group (sequence/choice/all), handling nested groups.
+*/
+function* walkGroup(group, source, schema, parentOptional = false, parentArray = false) {
+	if (!group) return;
+	const groupOptional = parentOptional || group.minOccurs === 0 || group.minOccurs === "0";
+	const groupArray = parentArray || isArray(group);
+	const choiceOptional = source === "choice";
+	if (group.element) for (const element of group.element) {
+		const optional = choiceOptional || groupOptional || element.minOccurs === 0 || element.minOccurs === "0";
+		const array = groupArray || isArray(element);
+		if (element.ref) {
+			const refName = stripNsPrefix(element.ref);
+			const refEntry = findElement(refName, schema);
+			if (refEntry && isAbstractElement(refEntry.element)) {
+				const substitutes = findSubstitutes(refName, schema);
+				if (substitutes.length > 0) {
+					for (const sub of substitutes) yield {
+						element: sub,
+						optional,
+						array,
+						source,
+						schema
+					};
+					continue;
+				}
+			}
+		}
+		yield {
+			element,
+			optional,
+			array,
+			source,
+			schema
+		};
+	}
+	if (group.sequence) {
+		const sequences = Array.isArray(group.sequence) ? group.sequence : [group.sequence];
+		for (const nested of sequences) yield* walkGroup(nested, "sequence", schema, groupOptional, groupArray);
+	}
+	if (group.choice) {
+		const choices = Array.isArray(group.choice) ? group.choice : [group.choice];
+		for (const nested of choices) yield* walkGroup(nested, "choice", schema, true, groupArray || isArray(nested));
+	}
+	if (group.group) {
+		const refs = Array.isArray(group.group) ? group.group : [group.group];
+		for (const ref of refs) if (ref.ref) yield* walkGroupRef(ref.ref, schema, groupOptional || choiceOptional, groupArray || isArray(ref));
+	}
+}
+/**
+* Walk elements from a group reference (xs:group ref="...").
+*/
+function* walkGroupRef(ref, schema, parentOptional = false, parentArray = false) {
+	const group = findGroup(stripNsPrefix(ref), schema);
+	if (group) {
+		if (group.sequence) yield* walkGroup(group.sequence, "sequence", schema, parentOptional, parentArray);
+		if (group.choice) yield* walkGroup(group.choice, "choice", schema, true, parentArray);
+		if (group.all) yield* walkGroup(group.all, "all", schema, parentOptional, parentArray);
+	}
+}
+/**
+* Walk all attributes in a complexType, handling:
+* - Direct attributes
+* - complexContent/extension attributes
+* - simpleContent/extension attributes
+* - Inherited attributes from base type
+* - AttributeGroup references
+*/
+function* walkAttributes(ct, schema) {
+	if (ct.complexContent?.extension) {
+		const ext = ct.complexContent.extension;
+		if (ext.base) {
+			const baseEntry = findComplexType(stripNsPrefix(ext.base), schema);
+			if (baseEntry) yield* walkAttributes(baseEntry.ct, baseEntry.schema);
+		}
+		if (ext.attribute) for (const attr of ext.attribute) {
+			const resolved = resolveAttribute(attr, schema);
+			if (resolved) yield {
+				attribute: resolved,
+				required: resolved.use === "required",
+				schema
+			};
+		}
+		yield* walkAttributeGroupRefs(ext.attributeGroup, schema);
+		return;
+	}
+	if (ct.simpleContent?.extension) {
+		const ext = ct.simpleContent.extension;
+		if (ext.attribute) for (const attr of ext.attribute) {
+			const resolved = resolveAttribute(attr, schema);
+			if (resolved) yield {
+				attribute: resolved,
+				required: resolved.use === "required",
+				schema
+			};
+		}
+		yield* walkAttributeGroupRefs(ext.attributeGroup, schema);
+		return;
+	}
+	if (ct.attribute) for (const attr of ct.attribute) {
+		const resolved = resolveAttribute(attr, schema);
+		if (resolved) yield {
+			attribute: resolved,
+			required: resolved.use === "required",
+			schema
+		};
+	}
+	yield* walkAttributeGroupRefs(ct.attributeGroup, schema);
+}
+/**
+* Walk attributes from attributeGroup references.
+*/
+function* walkAttributeGroupRefs(refs, schema) {
+	if (!refs) return;
+	for (const ref of refs) {
+		const refObj = ref;
+		if (refObj.ref) {
+			const group = findAttributeGroup(stripNsPrefix(refObj.ref), schema);
+			if (group?.attribute) for (const attribute of group.attribute) yield {
+				attribute,
+				required: attribute.use === "required",
+				schema
+			};
+		}
+	}
+}
+/**
+* Find a named group (xs:group) by name.
+*/
+function findGroup(name, schema) {
+	if (schema.group) {
+		for (const g of schema.group) if (g.name === name) return g;
+	}
+	if (schema.$includes) for (const included of schema.$includes) {
+		const found = findGroup(name, included);
+		if (found) return found;
+	}
+	if (schema.$imports) for (const imported of schema.$imports) {
+		const found = findGroup(name, imported);
+		if (found) return found;
+	}
+}
+/**
+* Find a top-level attribute by name.
+* Searches current schema and $imports.
+*/
+function findAttribute(name, schema) {
+	const schemaWithAttrs = schema;
+	if (schemaWithAttrs.attribute) {
+		for (const attr of schemaWithAttrs.attribute) if (attr.name === name) return attr;
+	}
+	if (schema.$includes) for (const included of schema.$includes) {
+		const found = findAttribute(name, included);
+		if (found) return found;
+	}
+	if (schema.$imports) for (const imported of schema.$imports) {
+		const found = findAttribute(name, imported);
+		if (found) return found;
+	}
+}
+/**
+* Resolve an attribute - handles both direct attributes and refs.
+* Returns the resolved attribute with its name.
+*/
+function resolveAttribute(attribute, schema) {
+	if (attribute.ref) {
+		const refName = stripNsPrefix(attribute.ref);
+		const resolved = findAttribute(refName, schema);
+		if (resolved) return {
+			...resolved,
+			use: attribute.use ?? resolved.use
+		};
+		return {
+			name: refName,
+			type: "xs:string",
+			use: attribute.use
+		};
+	}
+	return attribute;
+}
+/**
+* Find an attributeGroup by name.
+*/
+function findAttributeGroup(name, schema) {
+	if (schema.attributeGroup) {
+		for (const g of schema.attributeGroup) if (g.name === name) return g;
+	}
+	if (schema.$includes) for (const included of schema.$includes) {
+		const found = findAttributeGroup(name, included);
+		if (found) return found;
+	}
+	if (schema.$imports) for (const imported of schema.$imports) {
+		const found = findAttributeGroup(name, imported);
+		if (found) return found;
+	}
+}
+/**
+* Strip namespace prefix from a QName (e.g., "tns:PersonType" -> "PersonType")
+*/
+function stripNsPrefix(name) {
+	const colonIndex = name.indexOf(":");
+	return colonIndex >= 0 ? name.slice(colonIndex + 1) : name;
+}
+/**
+* Check if element/group has maxOccurs > 1 (is array)
+*/
+function isArray(item) {
+	if (item.maxOccurs === "unbounded") return true;
+	if (typeof item.maxOccurs === "number") return item.maxOccurs > 1;
+	if (typeof item.maxOccurs === "string") {
+		if (item.maxOccurs === "unbounded") return true;
+		const num = Number.parseInt(item.maxOccurs, 10);
+		return !Number.isNaN(num) && num > 1;
+	}
+	return false;
+}
+/**
+* Check if an element is abstract
+*/
+function isAbstractElement(element) {
+	return element.abstract === true || element.abstract === "true";
+}
+/**
+* Find all elements that substitute for a given abstract element.
+* This handles XSD substitution groups where concrete elements can
+* substitute for an abstract element.
+*/
+function findSubstitutes(abstractElementName, schema) {
+	const substitutes = [];
+	for (const { element } of walkTopLevelElements(schema)) {
+		const subGroup = element.substitutionGroup;
+		if (subGroup) {
+			if (stripNsPrefix(subGroup) === abstractElementName) substitutes.push(element);
+		}
+	}
+	return substitutes;
+}
+
+//#endregion
+//#region src/xml/parse.ts
+/**
+* XML Parser for W3C Schema
+*
+* Parse XML string to typed JavaScript object using W3C-compliant Schema definition.
+* Uses the walker module for schema traversal.
+*/
+/**
+* Find all elements that substitute for a given abstract element
+* Searches current schema and all $imports
+*/
+function findSubstitutingElements(abstractElementName, schema) {
+	const results = [];
+	const checkSchema = (s) => {
+		const elements = s.element;
+		if (!elements) return;
+		for (const el of elements) if (el.substitutionGroup) {
+			if (stripNsPrefix(el.substitutionGroup) === abstractElementName) results.push({
+				element: el,
+				schema: s
+			});
+		}
+	};
+	checkSchema(schema);
+	const imports = schema.$imports;
+	if (imports) for (const imported of imports) {
+		checkSchema(imported);
+		const nestedResults = findSubstitutingElements(abstractElementName, imported);
+		results.push(...nestedResults);
+	}
+	return results;
+}
+/**
+* Check if an element is abstract
+* Searches current schema and all $imports
+*/
+function isAbstractElement$1(elementName, schema) {
+	const elements = schema.element;
+	if (elements) {
+		for (const el of elements) if (el.name === elementName && el.abstract === true) return true;
+	}
+	const imports = schema.$imports;
+	if (imports) {
+		for (const imported of imports) if (isAbstractElement$1(elementName, imported)) return true;
+	}
+	return false;
+}
+/**
+* Parse XML string to typed object using schema definition
+*/
+function parse(schema, xml) {
+	const root = new DOMParser().parseFromString(xml, "text/xml")?.documentElement;
+	if (!root) throw new Error("Invalid XML: missing root element");
+	const rootLocalName = getLocalName(root);
+	const elementEntry = findElementByName(schema, rootLocalName);
+	if (!elementEntry) throw new Error(`Schema missing element declaration for: ${rootLocalName}`);
+	const inlineComplexType = elementEntry.element.complexType;
+	if (inlineComplexType) {
+		const content = parseElement(root, inlineComplexType, elementEntry.schema, schema);
+		return { [rootLocalName]: content };
+	}
+	const typeName = stripNsPrefix(elementEntry.element.type || elementEntry.element.name || "");
+	const typeEntry = findComplexType(typeName, schema);
+	if (!typeEntry) throw new Error(`Schema missing complexType for: ${typeName}`);
+	const content = parseElement(root, typeEntry.ct, typeEntry.schema, schema);
+	return { [rootLocalName]: content };
+}
+/**
+* Find element declaration by name (case-insensitive fallback)
+*/
+function findElementByName(schema, name) {
+	const exact = findElement(name, schema);
+	if (exact) return exact;
+	const elements = schema.element;
+	if (elements) {
+		const lowerName = name.toLowerCase();
+		const found = elements.find((el) => el.name?.toLowerCase() === lowerName);
+		if (found) return {
+			element: found,
+			schema
+		};
+	}
+}
+/**
+* Parse a single element using its complexType definition
+* Uses walker to iterate elements and attributes (handles inheritance automatically)
+* @param node - The XML element to parse
+* @param typeDef - The complexType definition for this element
+* @param schema - The schema where typeDef is defined (for type resolution)
+* @param rootSchema - The root schema (for substitution group lookups)
+*/
+function parseElement(node, typeDef, schema, rootSchema) {
+	const result = {};
+	if (typeDef.simpleContent?.extension) return parseSimpleContent(node, typeDef, schema, rootSchema);
+	for (const { attribute } of walkAttributes(typeDef, schema)) {
+		if (!attribute.name) continue;
+		const value = getAttributeValue(node, attribute.name);
+		if (value !== null) result[attribute.name] = convertValue(value, attribute.type || "string");
+		else if (attribute.default !== void 0) result[attribute.name] = convertValue(String(attribute.default), attribute.type || "string");
+	}
+	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 {
+			const children = getChildElements(node, resolved.name);
+			if (array || children.length > 1) {
+				const values = children.map((child) => parseChildValue(child, resolved.typeName, schema, rootSchema));
+				if (values.length > 0) result[resolved.name] = values;
+			} else if (children.length === 1) result[resolved.name] = parseChildValue(children[0], resolved.typeName, schema, rootSchema);
+		}
+	}
+	return result;
+}
+/**
+* Parse simpleContent (text content with attributes)
+*/
+function parseSimpleContent(node, typeDef, _schema, _rootSchema) {
+	const result = {};
+	const simpleContent = typeDef.simpleContent;
+	if (!simpleContent?.extension) return result;
+	const ext = simpleContent.extension;
+	result.$value = convertValue(getTextContent(node), ext.base ? stripNsPrefix(ext.base) : "string");
+	if (ext.attribute) for (const attrDef of ext.attribute) {
+		if (!attrDef.name) continue;
+		const value = getAttributeValue(node, attrDef.name);
+		if (value !== null) result[attrDef.name] = convertValue(value, attrDef.type || "string");
+		else if (attrDef.default !== void 0) result[attrDef.name] = convertValue(String(attrDef.default), attrDef.type || "string");
+	}
+	return result;
+}
+/**
+* Resolve element info (name and type), handling ref
+*/
+function resolveElementInfo$1(element, schema) {
+	if (element.name) return {
+		name: element.name,
+		typeName: element.type ? stripNsPrefix(element.type) : void 0
+	};
+	if (element.ref) {
+		const refName = stripNsPrefix(element.ref);
+		const refElement = findElement(refName, schema);
+		if (refElement) return {
+			name: refElement.element.name ?? refName,
+			typeName: refElement.element.type ? stripNsPrefix(refElement.element.type) : void 0
+		};
+		return {
+			name: refName,
+			typeName: void 0
+		};
+	}
+}
+/**
+* Parse a child element's value (either complex type or simple value)
+*/
+function parseChildValue(child, typeName, schema, rootSchema) {
+	const nestedType = typeName ? findComplexType(typeName, schema) : void 0;
+	if (nestedType) return parseElement(child, nestedType.ct, nestedType.schema, rootSchema);
+	return convertValue(getTextContent(child) || "", typeName || "string");
+}
+/**
+* Convert string value to typed value based on XSD type
+*/
+function convertValue(value, type) {
+	switch (stripNsPrefix(type)) {
+		case "int":
+		case "integer":
+		case "decimal":
+		case "float":
+		case "double":
+		case "short":
+		case "long":
+		case "byte":
+		case "unsignedInt":
+		case "unsignedShort":
+		case "unsignedLong":
+		case "unsignedByte":
+		case "positiveInteger":
+		case "negativeInteger":
+		case "nonPositiveInteger":
+		case "nonNegativeInteger": return Number(value);
+		case "boolean": return value === "true" || value === "1";
+		case "date":
+		case "dateTime": return value;
+		default: return value;
+	}
+}
+
+//#endregion
+//#region src/xml/build-utils.ts
+/**
+* Get namespace prefix from schema $xmlns declarations
+*/
+function getSchemaPrefix(schema) {
+	if (!schema.$xmlns || !schema.targetNamespace) return void 0;
+	for (const [prefix, uri] of Object.entries(schema.$xmlns)) if (uri === schema.targetNamespace && prefix) return prefix;
+}
+/**
+* Create XML document with namespace
+*/
+function createXmlDocument(schema) {
+	const impl = new DOMImplementation();
+	const ns = schema.targetNamespace || null;
+	return impl.createDocument(ns, "", null);
+}
+/**
+* Collect namespace declarations from a schema and its $imports/$includes recursively.
+*
+* Gathers all $xmlns prefix→URI mappings from the schema tree.
+* Unused declarations are cleaned up later by stripUnusedNamespaces()
+* after the XML tree is built — that approach is generic and doesn't
+* require any domain-specific knowledge.
+*/
+function collectAllNamespaces(schema, collected = /* @__PURE__ */ new Map(), visited = /* @__PURE__ */ new Set()) {
+	if (visited.has(schema)) return collected;
+	visited.add(schema);
+	if (schema.$xmlns) {
+		for (const [pfx, uri] of Object.entries(schema.$xmlns)) if (!collected.has(pfx)) collected.set(pfx, uri);
+	}
+	const imports = schema.$imports;
+	if (imports) for (const imported of imports) collectAllNamespaces(imported, collected, visited);
+	const includes = schema.$includes;
+	if (includes) for (const included of includes) collectAllNamespaces(included, collected, visited);
+	return collected;
+}
+/**
+* Create root element with namespace declarations
+*
+* When elementFormDefault="unqualified", the root element should NOT have
+* a namespace prefix. This is important for formats like abapGit where
+* the root element (abapGit) is unqualified but child elements may have prefixes.
+*/
+function createRootElement(doc, elementName, schema, prefix) {
+	const ns = schema.targetNamespace || null;
+	const usePrefix = schema.elementFormDefault === "unqualified" ? void 0 : prefix;
+	const rootTag = usePrefix ? `${usePrefix}:${elementName}` : elementName;
+	const root = doc.createElement(rootTag);
+	if (ns && prefix) root.setAttribute(`xmlns:${prefix}`, ns);
+	else if (ns && !prefix) root.setAttribute("xmlns", ns);
+	const allNamespaces = collectAllNamespaces(schema);
+	for (const [pfx, uri] of allNamespaces) if (pfx && pfx !== prefix) root.setAttribute(`xmlns:${pfx}`, uri);
+	else if (!pfx) root.setAttribute("xmlns", uri);
+	return root;
+}
+/**
+* Remove xmlns declarations from the root element for prefixes that are
+* not actually used anywhere in the document tree.
+*
+* This prevents emitting unused namespace declarations (e.g. xmlns:abapsource,
+* xmlns:abapoo) that come from the schema's $imports chain but aren't
+* referenced by any element or attribute in the built XML.
+*
+* The prefix that maps to the schema's own targetNamespace is always
+* preserved — even when elementFormDefault="unqualified" causes the root
+* element to be emitted without a prefix, the xmlns declaration is still
+* required for the document to be in the correct namespace.
+*/
+/**
+* Add namespace prefix from a qualified name to the set (if present).
+*/
+function addPrefixFromName(name, usedPrefixes) {
+	const colon = name.indexOf(":");
+	if (colon > 0) usedPrefixes.add(name.substring(0, colon));
+}
+/**
+* Collect namespace prefixes referenced by attributes on a single element
+* (xmlns declarations are skipped — they declare rather than use prefixes).
+*/
+function collectPrefixesFromAttributes(node, usedPrefixes) {
+	if (!node.attributes) return;
+	for (const attr of Array.from(node.attributes)) if (!attr.name.startsWith("xmlns:") && attr.name !== "xmlns") addPrefixFromName(attr.name, usedPrefixes);
+}
+/**
+* Collect prefixes used by elements and attributes in the tree (recursive walk).
+*/
+function collectUsedPrefixes(node, usedPrefixes) {
+	addPrefixFromName(node.tagName, usedPrefixes);
+	collectPrefixesFromAttributes(node, usedPrefixes);
+	if (node.childNodes) {
+		for (const child of Array.from(node.childNodes)) if (child.nodeType === 1) collectUsedPrefixes(child, usedPrefixes);
+	}
+}
+/**
+* Collect xmlns:prefix attribute names on the root element whose prefix
+* is not in the used-prefixes set.
+*/
+function findUnusedXmlnsAttrs(root, usedPrefixes) {
+	const toRemove = [];
+	if (!root.attributes) return toRemove;
+	for (const attr of Array.from(root.attributes)) if (attr.name.startsWith("xmlns:")) {
+		const pfx = attr.name.substring(6);
+		if (!usedPrefixes.has(pfx)) toRemove.push(attr.name);
+	}
+	return toRemove;
+}
+function stripUnusedNamespaces(root, schema) {
+	const usedPrefixes = /* @__PURE__ */ new Set();
+	if (schema?.targetNamespace && schema.$xmlns) {
+		for (const [pfx, uri] of Object.entries(schema.$xmlns)) if (pfx && uri === schema.targetNamespace) usedPrefixes.add(pfx);
+	}
+	collectUsedPrefixes(root, usedPrefixes);
+	for (const name of findUnusedXmlnsAttrs(root, usedPrefixes)) root.removeAttribute(name);
+}
+/**
+* Format value for XML output
+*/
+function formatValue(value, type) {
+	if (value instanceof Date) return stripNsPrefix(type) === "date" ? value.toISOString().split("T")[0] : value.toISOString();
+	if (typeof value === "boolean") return value ? "true" : "false";
+	return String(value);
+}
+/**
+* Simple XML formatter (basic indentation)
+*
+* Keeps text content inline: <tag>text</tag>
+* Only adds newlines for nested elements
+*/
+function formatXml(xml) {
+	let formatted = "";
+	let indent = 0;
+	const parts = [];
+	let pos = 0;
+	while (pos < xml.length) if (xml.charCodeAt(pos) === 60) {
+		const end = xml.indexOf(">", pos + 1);
+		if (end === -1) {
+			parts.push(xml.slice(pos));
+			break;
+		}
+		parts.push(xml.slice(pos, end + 1));
+		pos = end + 1;
+	} else {
+		const next = xml.indexOf("<", pos);
+		if (next === -1) {
+			parts.push(xml.slice(pos));
+			break;
+		}
+		if (next > pos) parts.push(xml.slice(pos, next));
+		pos = next;
+	}
+	let lastWasText = false;
+	for (let i = 0; i < parts.length; i++) {
+		const part = parts[i];
+		const nextPart = parts[i + 1];
+		if (part.startsWith("<?")) {
+			formatted += part + "\n";
+			lastWasText = false;
+		} else if (part.startsWith("</")) {
+			indent = Math.max(0, indent - 1);
+			if (lastWasText) formatted += part + "\n";
+			else formatted += "  ".repeat(indent) + part + "\n";
+			lastWasText = false;
+		} else if (part.startsWith("<") && part.endsWith("/>")) {
+			formatted += "  ".repeat(indent) + part + "\n";
+			lastWasText = false;
+		} else if (part.startsWith("<")) {
+			formatted += "  ".repeat(indent) + part;
+			if (!part.includes("</")) indent++;
+			if (nextPart && !nextPart.startsWith("<")) {} else formatted += "\n";
+			lastWasText = false;
+		} else {
+			const trimmed = part.trim();
+			if (trimmed) {
+				formatted += trimmed;
+				lastWasText = true;
+			}
+		}
+	}
+	return formatted.trim();
+}
+
+//#endregion
+//#region src/xml/build.ts
+/**
+* XML Builder for W3C Schema (Walker-based implementation)
+*
+* Build XML string from typed JavaScript object using W3C-compliant Schema definition.
+* Uses the walker module for schema traversal.
+*/
+/**
+* Collect all namespace prefixes from a schema and its $imports chain
+*/
+function collectAllXmlns(schema, visited = /* @__PURE__ */ new Set()) {
+	if (visited.has(schema)) return {};
+	visited.add(schema);
+	const result = {};
+	const xmlns = schema.$xmlns;
+	if (xmlns) Object.assign(result, xmlns);
+	const imports = schema.$imports;
+	if (imports) for (const imported of imports) Object.assign(result, collectAllXmlns(imported, visited));
+	return result;
+}
+/**
+* Get the namespace prefix for a schema's targetNamespace from the root schema's $xmlns
+* and all imported schemas' $xmlns (for inherited attributes)
+*/
+function getPrefixForSchema(schema, rootSchema) {
+	const targetNs = schema.targetNamespace;
+	if (!targetNs) return void 0;
+	const allXmlns = collectAllXmlns(rootSchema);
+	for (const [prefix, ns] of Object.entries(allXmlns)) if (ns === targetNs) return prefix;
+}
+/**
+* Build XML string from typed object using schema definition
+*/
+function build(schema, data, options = {}) {
+	const { xmlDecl = true, encoding = "utf-8", pretty = false } = options;
+	const prefix = options.prefix ?? getSchemaPrefix(schema);
+	const doc = createXmlDocument(schema);
+	let elementDecl;
+	let elementSchema = schema;
+	let elementData = data;
+	if (options.rootElement) {
+		const found = findElement(options.rootElement, schema);
+		if (!found) throw new Error(`Element '${options.rootElement}' not found in schema`);
+		elementDecl = found.element;
+		elementSchema = found.schema;
+		if (elementData[options.rootElement] !== void 0) elementData = elementData[options.rootElement];
+	} else {
+		const dataKeys = Object.keys(elementData);
+		if (dataKeys.length === 1) {
+			const potentialElementName = dataKeys[0];
+			const found = findElement(potentialElementName, schema);
+			if (found) {
+				elementDecl = found.element;
+				elementSchema = found.schema;
+				elementData = elementData[potentialElementName];
+			}
+		}
+		if (!elementDecl) {
+			elementDecl = findMatchingElement(elementData, schema);
+			if (!elementDecl) throw new Error("Schema has no element declarations");
+		}
+	}
+	let rootType;
+	let rootSchema = elementSchema;
+	if (elementDecl.complexType) rootType = elementDecl.complexType;
+	else if (elementDecl.type) {
+		const typeName = stripNsPrefix(elementDecl.type);
+		const rootTypeEntry = findComplexType(typeName, elementSchema);
+		if (!rootTypeEntry) throw new Error(`Schema missing complexType for: ${typeName}`);
+		rootType = rootTypeEntry.ct;
+		rootSchema = rootTypeEntry.schema;
+	} else throw new Error(`Element ${elementDecl.name} has no type or inline complexType`);
+	const elementName = elementDecl.name ?? elementDecl.ref;
+	if (!elementName) throw new Error("Element declaration has no name or ref");
+	const root = createRootElement(doc, elementName, schema, prefix);
+	buildElement(doc, root, elementData, rootType, rootSchema, schema, prefix);
+	stripUnusedNamespaces(root, schema);
+	if (!root.hasChildNodes()) root.appendChild(doc.createTextNode(""));
+	doc.appendChild(root);
+	let xml = new XMLSerializer().serializeToString(doc);
+	if (xmlDecl) xml = `<?xml version="1.0" encoding="${encoding}"?>\n${xml}`;
+	if (pretty) xml = formatXml(xml);
+	return xml;
+}
+/**
+* Find the element declaration that best matches the data structure.
+* Searches in the main schema first, then in $imports.
+*/
+function findMatchingElement(data, schema) {
+	const dataKeys = new Set(Object.keys(data));
+	let bestMatch;
+	let bestScore = -1;
+	const scoreElement = (element, searchSchema) => {
+		let ct;
+		let ctSchema = searchSchema;
+		if (element.complexType) ct = element.complexType;
+		else if (element.type) {
+			const typeName = stripNsPrefix(element.type);
+			const typeEntry = findComplexType(typeName, searchSchema);
+			if (typeEntry) {
+				ct = typeEntry.ct;
+				ctSchema = typeEntry.schema;
+			}
+		}
+		if (!ct) return 0;
+		const typeFields = /* @__PURE__ */ new Set();
+		for (const { element: el } of walkElements(ct, ctSchema)) if (el.name) typeFields.add(el.name);
+		for (const { attribute } of walkAttributes(ct, ctSchema)) if (attribute.name) typeFields.add(attribute.name);
+		let score = 0;
+		dataKeys.forEach((key) => {
+			if (typeFields.has(key)) score++;
+		});
+		return score;
+	};
+	const elements = schema.element;
+	if (elements && elements.length > 0) for (const element of elements) {
+		const score = scoreElement(element, schema);
+		if (score > bestScore) {
+			bestScore = score;
+			bestMatch = element;
+		}
+	}
+	const imports = schema.$imports;
+	if (imports) for (const importedSchema of imports) {
+		const importedElements = importedSchema.element;
+		if (!importedElements) continue;
+		for (const element of importedElements) {
+			const score = scoreElement(element, importedSchema);
+			if (score > bestScore) {
+				bestScore = score;
+				bestMatch = element;
+			}
+		}
+	}
+	if (!bestMatch && elements && elements.length > 0) return elements[0];
+	return bestMatch;
+}
+/**
+* Build element content using its complexType definition
+* Uses walker to iterate elements and attributes (handles inheritance automatically)
+* @param rootSchema - The original schema passed to build(), used for substitution group lookup
+*/
+function buildElement(doc, node, data, typeDef, schema, rootSchema, prefix) {
+	for (const { attribute, schema: attrSchema } of walkAttributes(typeDef, schema)) {
+		if (!attribute.name) continue;
+		const value = data[attribute.name];
+		if (value !== void 0 && value !== null) {
+			const attributeFormDefault = attrSchema.attributeFormDefault;
+			const attrForm = attribute.form;
+			let attrName = attribute.name;
+			if (attrForm === "qualified" || attrForm !== "unqualified" && attributeFormDefault === "qualified") {
+				const attrPrefix = getPrefixForSchema(attrSchema, rootSchema);
+				if (attrPrefix) attrName = `${attrPrefix}:${attribute.name}`;
+			}
+			node.setAttribute(attrName, formatValue(value, attribute.type || "string"));
+		}
+	}
+	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 != null) buildField(doc, node, value, subName, substitute.element.type ? stripNsPrefix(substitute.element.type) : void 0, substitute.schema, rootSchema, prefix);
+				}
+				continue;
+			}
+		}
+		const resolved = resolveElementInfo(element, elementDefSchema);
+		if (!resolved) continue;
+		const value = data[resolved.dataKey];
+		if (value != null) buildFieldWithTagName(doc, node, value, resolved.tagName, resolved.typeName, resolved.inlineComplexType, resolved.elementSchema, rootSchema, prefix, resolved.form);
+	}
+}
+/**
+* Resolve element info (name and type), handling ref
+*
+* Returns:
+* - tagName: The XML tag name to use (may include prefix like "asx:abap")
+* - dataKey: The key to look up in data object (local name without prefix)
+* - typeName: The type name for building nested content (if type attribute)
+* - inlineComplexType: The inline complexType definition (if present)
+* - elementSchema: The schema where the element was found
+* - form: Per-element form override ("qualified" or "unqualified")
+*/
+function resolveElementInfo(element, schema) {
+	if (element.name) return {
+		tagName: element.name,
+		dataKey: element.name,
+		typeName: element.type ? stripNsPrefix(element.type) : void 0,
+		inlineComplexType: element.complexType,
+		elementSchema: schema,
+		form: element.form
+	};
+	if (element.ref) {
+		const refName = stripNsPrefix(element.ref);
+		const refElement = findElement(refName, schema);
+		if (refElement) return {
+			tagName: element.ref,
+			dataKey: refElement.element.name ?? refName,
+			typeName: refElement.element.type ? stripNsPrefix(refElement.element.type) : void 0,
+			inlineComplexType: refElement.element.complexType,
+			elementSchema: refElement.schema,
+			form: void 0
+		};
+		return {
+			tagName: element.ref,
+			dataKey: refName,
+			typeName: void 0,
+			inlineComplexType: void 0,
+			elementSchema: schema,
+			form: void 0
+		};
+	}
+}
+/**
+* Build a field (child element)
+*
+* Respects elementFormDefault:
+* - "qualified": local elements get namespace prefix
+* - "unqualified" (default): local elements do NOT get namespace prefix
+*/
+function buildField(doc, parent, value, elementName, typeName, schema, rootSchema, prefix) {
+	const nestedType = typeName ? findComplexType(typeName, schema) : void 0;
+	const usePrefix = rootSchema.elementFormDefault === "qualified" ? prefix : void 0;
+	const tagName = usePrefix ? `${usePrefix}:${elementName}` : elementName;
+	if (Array.isArray(value)) for (const item of value) {
+		const child = doc.createElement(tagName);
+		if (nestedType) buildElement(doc, child, item, nestedType.ct, nestedType.schema, rootSchema, prefix);
+		else {
+			const text = formatValue(item, typeName || "string");
+			if (text) child.appendChild(doc.createTextNode(text));
+		}
+		parent.appendChild(child);
+	}
+	else {
+		const child = doc.createElement(tagName);
+		if (nestedType) buildElement(doc, child, value, nestedType.ct, nestedType.schema, rootSchema, prefix);
+		else {
+			const text = formatValue(value, typeName || "string");
+			if (text) child.appendChild(doc.createTextNode(text));
+		}
+		parent.appendChild(child);
+	}
+}
+/**
+* Build a field with an explicit tag name (used for element refs with prefix)
+*
+* Handles three cases:
+* 1. Element refs with prefix (e.g., ref="asx:abap") - use tagName directly
+* 2. Elements with form="unqualified" - never use prefix
+* 3. Direct elements - apply elementFormDefault logic
+*/
+function buildFieldWithTagName(doc, parent, value, tagName, typeName, inlineComplexType, elementSchema, rootSchema, prefix, elementForm) {
+	let nestedType;
+	if (inlineComplexType) nestedType = {
+		ct: inlineComplexType,
+		schema: elementSchema
+	};
+	else if (typeName) nestedType = findComplexType(typeName, elementSchema);
+	let actualTagName = tagName;
+	if (!tagName.includes(":")) {
+		let usePrefix;
+		if (elementForm === "unqualified") usePrefix = void 0;
+		else if (elementForm === "qualified") usePrefix = getPrefixForSchema(elementSchema, rootSchema) ?? prefix;
+		else usePrefix = (elementSchema.elementFormDefault ?? rootSchema.elementFormDefault) === "qualified" ? getPrefixForSchema(elementSchema, rootSchema) ?? prefix : void 0;
+		actualTagName = usePrefix ? `${usePrefix}:${tagName}` : tagName;
+	}
+	if (Array.isArray(value)) for (const item of value) {
+		const child = doc.createElement(actualTagName);
+		if (nestedType) buildElement(doc, child, item, nestedType.ct, nestedType.schema, rootSchema, prefix);
+		else {
+			const text = formatValue(item, typeName || "string");
+			if (text) child.appendChild(doc.createTextNode(text));
+		}
+		parent.appendChild(child);
+	}
+	else {
+		const child = doc.createElement(actualTagName);
+		if (nestedType) buildElement(doc, child, value, nestedType.ct, nestedType.schema, rootSchema, prefix);
+		else {
+			const text = formatValue(value, typeName || "string");
+			if (text) child.appendChild(doc.createTextNode(text));
+		}
+		parent.appendChild(child);
+	}
+}
+/**
+* Find all elements that substitute for a given abstract element name.
+* Searches in the main schema and all $imports.
+*/
+function findSubstitutes$1(abstractElementName, schema) {
+	const substitutes = [];
+	const searchSchema = (s) => {
+		const elements = s.element;
+		if (!elements) return;
+		for (const el of elements) if (el.substitutionGroup) {
+			if (stripNsPrefix(el.substitutionGroup) === abstractElementName) substitutes.push({
+				element: el,
+				schema: s
+			});
+		}
+	};
+	searchSchema(schema);
+	const imports = schema.$imports;
+	if (imports) for (const imported of imports) searchSchema(imported);
+	return substitutes;
+}
+
+//#endregion
+//#region src/xml/typed.ts
+/**
+* Create a typed schema wrapper
+*
+* @param schema - Raw schema literal (with `as const`)
+* @returns Typed schema with parse/build methods
+*
+* @example
+* ```typescript
+* // Infer type from schema
+* const personSchema = typedSchema(rawPersonSchema);
+* const person = personSchema.parse(xml);
+*
+* // Or with explicit type
+* const personSchema = typedSchema<PersonType>(rawPersonSchema);
+* ```
+*/
+function typedSchema(schema) {
+	return {
+		_type: null,
+		schema,
+		parse(xml) {
+			return parse(schema, xml);
+		},
+		build(data, options) {
+			return build(schema, data, options);
+		}
+	};
+}
+
+//#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 };
+//# sourceMappingURL=index.mjs.map