@abapify/ts-xsd 0.4.0 → 0.4.1

package/dist/runner-CRhT3smd.mjs

@@ -0,0 +1,2651 @@
+import { DOMParser } from "@xmldom/xmldom";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
+
+//#region src/xml/dom-utils.ts
+/**
+* Type guard to check if a Node is an Element
+*/
+function isElement(node) {
+	return node.nodeType === 1;
+}
+/**
+* Get attribute value, handling namespaced attributes
+* Tries direct attribute first, then searches by local name
+*/
+function getAttributeValue(node, name) {
+	if (node.hasAttribute(name)) return node.getAttribute(name);
+	for (let i = 0; i < node.attributes.length; i++) {
+		const attr = node.attributes[i];
+		if ((attr.localName || attr.name.split(":").pop()) === name) return attr.value;
+	}
+	return null;
+}
+/**
+* Get child elements by local name (namespace-agnostic)
+*/
+function getChildElements(parent, name) {
+	const result = [];
+	for (let i = 0; i < parent.childNodes.length; i++) {
+		const child = parent.childNodes[i];
+		if (isElement(child)) {
+			if ((child.localName || child.tagName.split(":").pop()) === name) result.push(child);
+		}
+	}
+	return result;
+}
+/**
+* Get all child elements (any name)
+*/
+function getAllChildElements(parent) {
+	const result = [];
+	for (let i = 0; i < parent.childNodes.length; i++) {
+		const child = parent.childNodes[i];
+		if (isElement(child)) result.push(child);
+	}
+	return result;
+}
+/**
+* Get text content of an element (concatenates all text nodes)
+*/
+function getTextContent(node) {
+	let text = "";
+	for (let i = 0; i < node.childNodes.length; i++) {
+		const child = node.childNodes[i];
+		if (child.nodeType === 3) text += child.textContent || "";
+	}
+	return text.trim();
+}
+/**
+* Get local name of an element (strips namespace prefix)
+*/
+function getLocalName(node) {
+	return node.localName || node.tagName.split(":").pop() || node.tagName;
+}
+
+//#endregion
+//#region src/xsd/parse.ts
+/**
+* XSD Parser - Parse XSD documents to typed Schema objects
+*
+* This parser understands XSD semantics and produces correctly typed output
+* matching the W3C XMLSchema.xsd specification.
+*
+* No intermediate JSON - direct XSD to typed objects.
+*/
+/**
+* Parse an XSD string to a typed Schema object
+*/
+function parseXsd(xml) {
+	const root = new DOMParser().parseFromString(xml, "text/xml").documentElement;
+	if (!root || getLocalName(root) !== "schema") throw new Error("Invalid XSD: root element must be xs:schema");
+	return parseSchema(root);
+}
+function parseSchema(el) {
+	const schema = {};
+	copyXmlns(el, schema);
+	copyAttr(el, schema, "id");
+	copyAttr(el, schema, "targetNamespace");
+	copyAttr(el, schema, "version");
+	copyAttr(el, schema, "finalDefault");
+	copyAttr(el, schema, "blockDefault");
+	copyAttr(el, schema, "attributeFormDefault");
+	copyAttr(el, schema, "elementFormDefault");
+	copyAttr(el, schema, "defaultAttributes");
+	copyAttr(el, schema, "xpathDefaultNamespace");
+	copyAttr(el, schema, "xml:lang");
+	for (const child of getAllChildElements(el)) switch (getLocalName(child)) {
+		case "annotation":
+			pushTo(schema, "annotation", parseAnnotation(child));
+			break;
+		case "include":
+			pushTo(schema, "include", parseInclude(child));
+			break;
+		case "import":
+			pushTo(schema, "import", parseImport(child));
+			break;
+		case "redefine":
+			pushTo(schema, "redefine", parseRedefine(child));
+			break;
+		case "override":
+			pushTo(schema, "override", parseOverride(child));
+			break;
+		case "element":
+			pushTo(schema, "element", parseTopLevelElement(child));
+			break;
+		case "attribute":
+			pushTo(schema, "attribute", parseTopLevelAttribute(child));
+			break;
+		case "simpleType":
+			pushTo(schema, "simpleType", parseTopLevelSimpleType(child));
+			break;
+		case "complexType":
+			pushTo(schema, "complexType", parseTopLevelComplexType(child));
+			break;
+		case "group":
+			pushTo(schema, "group", parseNamedGroup(child));
+			break;
+		case "attributeGroup":
+			pushTo(schema, "attributeGroup", parseNamedAttributeGroup(child));
+			break;
+		case "notation":
+			pushTo(schema, "notation", parseNotation(child));
+			break;
+		case "defaultOpenContent":
+			schema.defaultOpenContent = parseDefaultOpenContent(child);
+			break;
+	}
+	return schema;
+}
+function parseAnnotation(el) {
+	const result = {};
+	copyAttr(el, result, "id");
+	for (const child of getAllChildElements(el)) {
+		const name = getLocalName(child);
+		if (name === "documentation") pushTo(result, "documentation", parseDocumentation(child));
+		else if (name === "appinfo") pushTo(result, "appinfo", parseAppinfo(child));
+	}
+	return result;
+}
+function parseDocumentation(el) {
+	const result = {};
+	copyAttr(el, result, "source");
+	copyAttr(el, result, "xml:lang");
+	const text = getTextContent(el);
+	if (text) result._text = text;
+	return result;
+}
+function parseAppinfo(el) {
+	const result = {};
+	copyAttr(el, result, "source");
+	const text = getTextContent(el);
+	if (text) result._text = text;
+	return result;
+}
+function parseInclude(el) {
+	const result = { schemaLocation: "" };
+	copyAttr(el, result, "id");
+	copyAttr(el, result, "schemaLocation");
+	parseAnnotationChild(el, result);
+	return result;
+}
+function parseImport(el) {
+	const result = {};
+	copyAttr(el, result, "id");
+	copyAttr(el, result, "namespace");
+	copyAttr(el, result, "schemaLocation");
+	parseAnnotationChild(el, result);
+	return result;
+}
+function parseRedefine(el) {
+	const result = { schemaLocation: "" };
+	copyAttr(el, result, "id");
+	copyAttr(el, result, "schemaLocation");
+	for (const child of getAllChildElements(el)) switch (getLocalName(child)) {
+		case "annotation":
+			pushTo(result, "annotation", parseAnnotation(child));
+			break;
+		case "simpleType":
+			pushTo(result, "simpleType", parseTopLevelSimpleType(child));
+			break;
+		case "complexType":
+			pushTo(result, "complexType", parseTopLevelComplexType(child));
+			break;
+		case "group":
+			pushTo(result, "group", parseNamedGroup(child));
+			break;
+		case "attributeGroup":
+			pushTo(result, "attributeGroup", parseNamedAttributeGroup(child));
+			break;
+	}
+	return result;
+}
+function parseOverride(el) {
+	const result = { schemaLocation: "" };
+	copyAttr(el, result, "id");
+	copyAttr(el, result, "schemaLocation");
+	for (const child of getAllChildElements(el)) switch (getLocalName(child)) {
+		case "annotation":
+			pushTo(result, "annotation", parseAnnotation(child));
+			break;
+		case "simpleType":
+			pushTo(result, "simpleType", parseTopLevelSimpleType(child));
+			break;
+		case "complexType":
+			pushTo(result, "complexType", parseTopLevelComplexType(child));
+			break;
+		case "group":
+			pushTo(result, "group", parseNamedGroup(child));
+			break;
+		case "attributeGroup":
+			pushTo(result, "attributeGroup", parseNamedAttributeGroup(child));
+			break;
+		case "element":
+			pushTo(result, "element", parseTopLevelElement(child));
+			break;
+		case "attribute":
+			pushTo(result, "attribute", parseTopLevelAttribute(child));
+			break;
+		case "notation":
+			pushTo(result, "notation", parseNotation(child));
+			break;
+	}
+	return result;
+}
+function parseTopLevelElement(el) {
+	const result = { name: "" };
+	copyAttr(el, result, "id");
+	copyAttr(el, result, "name");
+	copyAttr(el, result, "type");
+	copyAttr(el, result, "substitutionGroup");
+	copyAttr(el, result, "default");
+	copyAttr(el, result, "fixed");
+	copyBoolAttr(el, result, "nillable");
+	copyBoolAttr(el, result, "abstract");
+	copyAttr(el, result, "final");
+	copyAttr(el, result, "block");
+	parseAnnotationChild(el, result);
+	for (const child of getAllChildElements(el)) switch (getLocalName(child)) {
+		case "simpleType":
+			result.simpleType = parseLocalSimpleType(child);
+			break;
+		case "complexType":
+			result.complexType = parseLocalComplexType(child);
+			break;
+		case "unique":
+			pushTo(result, "unique", parseUnique(child));
+			break;
+		case "key":
+			pushTo(result, "key", parseKey(child));
+			break;
+		case "keyref":
+			pushTo(result, "keyref", parseKeyref(child));
+			break;
+		case "alternative":
+			pushTo(result, "alternative", parseAlternative(child));
+			break;
+	}
+	return result;
+}
+function parseLocalElement(el) {
+	const result = {};
+	copyAttr(el, result, "id");
+	copyAttr(el, result, "name");
+	copyAttr(el, result, "ref");
+	copyAttr(el, result, "type");
+	copyAttr(el, result, "minOccurs");
+	copyAttr(el, result, "maxOccurs");
+	copyAttr(el, result, "default");
+	copyAttr(el, result, "fixed");
+	copyBoolAttr(el, result, "nillable");
+	copyAttr(el, result, "block");
+	copyAttr(el, result, "form");
+	copyAttr(el, result, "targetNamespace");
+	parseAnnotationChild(el, result);
+	for (const child of getAllChildElements(el)) switch (getLocalName(child)) {
+		case "simpleType":
+			result.simpleType = parseLocalSimpleType(child);
+			break;
+		case "complexType":
+			result.complexType = parseLocalComplexType(child);
+			break;
+		case "unique":
+			pushTo(result, "unique", parseUnique(child));
+			break;
+		case "key":
+			pushTo(result, "key", parseKey(child));
+			break;
+		case "keyref":
+			pushTo(result, "keyref", parseKeyref(child));
+			break;
+		case "alternative":
+			pushTo(result, "alternative", parseAlternative(child));
+			break;
+	}
+	return result;
+}
+function parseTopLevelAttribute(el) {
+	const result = { name: "" };
+	copyAttr(el, result, "id");
+	copyAttr(el, result, "name");
+	copyAttr(el, result, "type");
+	copyAttr(el, result, "default");
+	copyAttr(el, result, "fixed");
+	copyBoolAttr(el, result, "inheritable");
+	parseAnnotationChild(el, result);
+	for (const child of getAllChildElements(el)) if (getLocalName(child) === "simpleType") result.simpleType = parseLocalSimpleType(child);
+	return result;
+}
+function parseLocalAttribute(el) {
+	const result = {};
+	copyAttr(el, result, "id");
+	copyAttr(el, result, "name");
+	copyAttr(el, result, "ref");
+	copyAttr(el, result, "type");
+	copyAttr(el, result, "use");
+	copyAttr(el, result, "default");
+	copyAttr(el, result, "fixed");
+	copyAttr(el, result, "form");
+	copyAttr(el, result, "targetNamespace");
+	copyBoolAttr(el, result, "inheritable");
+	parseAnnotationChild(el, result);
+	for (const child of getAllChildElements(el)) if (getLocalName(child) === "simpleType") result.simpleType = parseLocalSimpleType(child);
+	return result;
+}
+function parseTopLevelComplexType(el) {
+	const result = { name: "" };
+	copyAttr(el, result, "id");
+	copyAttr(el, result, "name");
+	copyBoolAttr(el, result, "mixed");
+	copyBoolAttr(el, result, "abstract");
+	copyAttr(el, result, "final");
+	copyAttr(el, result, "block");
+	copyBoolAttr(el, result, "defaultAttributesApply");
+	parseAnnotationChild(el, result);
+	parseComplexTypeContent(el, result);
+	return result;
+}
+function parseLocalComplexType(el) {
+	const result = {};
+	copyAttr(el, result, "id");
+	copyBoolAttr(el, result, "mixed");
+	parseAnnotationChild(el, result);
+	parseComplexTypeContent(el, result);
+	return result;
+}
+function parseComplexTypeContent(el, result) {
+	for (const child of getAllChildElements(el)) switch (getLocalName(child)) {
+		case "simpleContent":
+			result.simpleContent = parseSimpleContent(child);
+			break;
+		case "complexContent":
+			result.complexContent = parseComplexContent(child);
+			break;
+		case "openContent":
+			result.openContent = parseOpenContent(child);
+			break;
+		case "group":
+			result.group = parseGroupRef(child);
+			break;
+		case "all":
+			result.all = parseAll(child);
+			break;
+		case "choice":
+			result.choice = parseExplicitGroup(child);
+			break;
+		case "sequence":
+			result.sequence = parseExplicitGroup(child);
+			break;
+		case "attribute":
+			pushTo(result, "attribute", parseLocalAttribute(child));
+			break;
+		case "attributeGroup":
+			pushTo(result, "attributeGroup", parseAttributeGroupRef(child));
+			break;
+		case "anyAttribute":
+			result.anyAttribute = parseAnyAttribute(child);
+			break;
+		case "assert":
+			pushTo(result, "assert", parseAssertion(child));
+			break;
+	}
+}
+function parseTopLevelSimpleType(el) {
+	const result = { name: "" };
+	copyAttr(el, result, "id");
+	copyAttr(el, result, "name");
+	copyAttr(el, result, "final");
+	parseAnnotationChild(el, result);
+	parseSimpleTypeContent(el, result);
+	return result;
+}
+function parseLocalSimpleType(el) {
+	const result = {};
+	copyAttr(el, result, "id");
+	parseAnnotationChild(el, result);
+	parseSimpleTypeContent(el, result);
+	return result;
+}
+function parseSimpleTypeContent(el, result) {
+	for (const child of getAllChildElements(el)) switch (getLocalName(child)) {
+		case "restriction":
+			result.restriction = parseSimpleTypeRestriction(child);
+			break;
+		case "list":
+			result.list = parseList(child);
+			break;
+		case "union":
+			result.union = parseUnion(child);
+			break;
+	}
+}
+function parseSimpleTypeRestriction(el) {
+	const result = {};
+	copyAttr(el, result, "id");
+	copyAttr(el, result, "base");
+	parseAnnotationChild(el, result);
+	for (const child of getAllChildElements(el)) {
+		const name = getLocalName(child);
+		switch (name) {
+			case "simpleType":
+				result.simpleType = parseLocalSimpleType(child);
+				break;
+			case "minExclusive":
+			case "minInclusive":
+			case "maxExclusive":
+			case "maxInclusive":
+			case "totalDigits":
+			case "fractionDigits":
+			case "length":
+			case "minLength":
+			case "maxLength":
+			case "enumeration":
+			case "whiteSpace":
+			case "explicitTimezone":
+				pushTo(result, name, parseFacet(child));
+				break;
+			case "pattern":
+				pushTo(result, "pattern", parsePattern(child));
+				break;
+			case "assertion":
+				pushTo(result, "assertion", parseAssertion(child));
+				break;
+		}
+	}
+	return result;
+}
+function parseList(el) {
+	const result = {};
+	copyAttr(el, result, "id");
+	copyAttr(el, result, "itemType");
+	parseAnnotationChild(el, result);
+	for (const child of getAllChildElements(el)) if (getLocalName(child) === "simpleType") result.simpleType = parseLocalSimpleType(child);
+	return result;
+}
+function parseUnion(el) {
+	const result = {};
+	copyAttr(el, result, "id");
+	copyAttr(el, result, "memberTypes");
+	parseAnnotationChild(el, result);
+	for (const child of getAllChildElements(el)) if (getLocalName(child) === "simpleType") pushTo(result, "simpleType", parseLocalSimpleType(child));
+	return result;
+}
+function parseFacet(el) {
+	const result = { value: "" };
+	copyAttr(el, result, "id");
+	copyAttr(el, result, "value");
+	copyBoolAttr(el, result, "fixed");
+	parseAnnotationChild(el, result);
+	return result;
+}
+function parsePattern(el) {
+	const result = { value: "" };
+	copyAttr(el, result, "id");
+	copyAttr(el, result, "value");
+	parseAnnotationChild(el, result);
+	return result;
+}
+function parseComplexContent(el) {
+	const result = {};
+	copyAttr(el, result, "id");
+	copyBoolAttr(el, result, "mixed");
+	parseAnnotationChild(el, result);
+	for (const child of getAllChildElements(el)) {
+		const name = getLocalName(child);
+		if (name === "restriction") result.restriction = parseComplexContentRestriction(child);
+		else if (name === "extension") result.extension = parseComplexContentExtension(child);
+	}
+	return result;
+}
+function parseSimpleContent(el) {
+	const result = {};
+	copyAttr(el, result, "id");
+	parseAnnotationChild(el, result);
+	for (const child of getAllChildElements(el)) {
+		const name = getLocalName(child);
+		if (name === "restriction") result.restriction = parseSimpleContentRestriction(child);
+		else if (name === "extension") result.extension = parseSimpleContentExtension(child);
+	}
+	return result;
+}
+function parseComplexContentRestriction(el) {
+	const result = { base: "" };
+	copyAttr(el, result, "id");
+	copyAttr(el, result, "base");
+	parseAnnotationChild(el, result);
+	parseComplexTypeContent(el, result);
+	return result;
+}
+function parseComplexContentExtension(el) {
+	const result = { base: "" };
+	copyAttr(el, result, "id");
+	copyAttr(el, result, "base");
+	parseAnnotationChild(el, result);
+	parseComplexTypeContent(el, result);
+	return result;
+}
+function parseSimpleContentRestriction(el) {
+	const result = { base: "" };
+	copyAttr(el, result, "id");
+	copyAttr(el, result, "base");
+	parseAnnotationChild(el, result);
+	for (const child of getAllChildElements(el)) {
+		const name = getLocalName(child);
+		switch (name) {
+			case "simpleType":
+				result.simpleType = parseLocalSimpleType(child);
+				break;
+			case "minExclusive":
+			case "minInclusive":
+			case "maxExclusive":
+			case "maxInclusive":
+			case "totalDigits":
+			case "fractionDigits":
+			case "length":
+			case "minLength":
+			case "maxLength":
+			case "enumeration":
+			case "whiteSpace":
+			case "explicitTimezone":
+				pushTo(result, name, parseFacet(child));
+				break;
+			case "pattern":
+				pushTo(result, "pattern", parsePattern(child));
+				break;
+			case "assertion":
+				pushTo(result, "assertion", parseAssertion(child));
+				break;
+			case "attribute":
+				pushTo(result, "attribute", parseLocalAttribute(child));
+				break;
+			case "attributeGroup":
+				pushTo(result, "attributeGroup", parseAttributeGroupRef(child));
+				break;
+			case "anyAttribute":
+				result.anyAttribute = parseAnyAttribute(child);
+				break;
+			case "assert":
+				pushTo(result, "assert", parseAssertion(child));
+				break;
+		}
+	}
+	return result;
+}
+function parseSimpleContentExtension(el) {
+	const result = { base: "" };
+	copyAttr(el, result, "id");
+	copyAttr(el, result, "base");
+	parseAnnotationChild(el, result);
+	for (const child of getAllChildElements(el)) switch (getLocalName(child)) {
+		case "attribute":
+			pushTo(result, "attribute", parseLocalAttribute(child));
+			break;
+		case "attributeGroup":
+			pushTo(result, "attributeGroup", parseAttributeGroupRef(child));
+			break;
+		case "anyAttribute":
+			result.anyAttribute = parseAnyAttribute(child);
+			break;
+		case "assert":
+			pushTo(result, "assert", parseAssertion(child));
+			break;
+	}
+	return result;
+}
+function parseExplicitGroup(el) {
+	const result = {};
+	copyAttr(el, result, "id");
+	copyAttr(el, result, "minOccurs");
+	copyAttr(el, result, "maxOccurs");
+	parseAnnotationChild(el, result);
+	for (const child of getAllChildElements(el)) switch (getLocalName(child)) {
+		case "element":
+			pushTo(result, "element", parseLocalElement(child));
+			break;
+		case "group":
+			pushTo(result, "group", parseGroupRef(child));
+			break;
+		case "choice":
+			pushTo(result, "choice", parseExplicitGroup(child));
+			break;
+		case "sequence":
+			pushTo(result, "sequence", parseExplicitGroup(child));
+			break;
+		case "any":
+			pushTo(result, "any", parseAny(child));
+			break;
+	}
+	return result;
+}
+function parseAll(el) {
+	const result = {};
+	copyAttr(el, result, "id");
+	copyAttr(el, result, "minOccurs");
+	copyAttr(el, result, "maxOccurs");
+	parseAnnotationChild(el, result);
+	for (const child of getAllChildElements(el)) switch (getLocalName(child)) {
+		case "element":
+			pushTo(result, "element", parseLocalElement(child));
+			break;
+		case "any":
+			pushTo(result, "any", parseAny(child));
+			break;
+		case "group":
+			pushTo(result, "group", parseGroupRef(child));
+			break;
+	}
+	return result;
+}
+function parseNamedGroup(el) {
+	const result = { name: "" };
+	copyAttr(el, result, "id");
+	copyAttr(el, result, "name");
+	parseAnnotationChild(el, result);
+	for (const child of getAllChildElements(el)) switch (getLocalName(child)) {
+		case "all":
+			result.all = parseAll(child);
+			break;
+		case "choice":
+			result.choice = parseExplicitGroup(child);
+			break;
+		case "sequence":
+			result.sequence = parseExplicitGroup(child);
+			break;
+	}
+	return result;
+}
+function parseGroupRef(el) {
+	const result = { ref: "" };
+	copyAttr(el, result, "id");
+	copyAttr(el, result, "ref");
+	copyAttr(el, result, "minOccurs");
+	copyAttr(el, result, "maxOccurs");
+	parseAnnotationChild(el, result);
+	return result;
+}
+function parseNamedAttributeGroup(el) {
+	const result = { name: "" };
+	copyAttr(el, result, "id");
+	copyAttr(el, result, "name");
+	parseAnnotationChild(el, result);
+	for (const child of getAllChildElements(el)) switch (getLocalName(child)) {
+		case "attribute":
+			pushTo(result, "attribute", parseLocalAttribute(child));
+			break;
+		case "attributeGroup":
+			pushTo(result, "attributeGroup", parseAttributeGroupRef(child));
+			break;
+		case "anyAttribute":
+			result.anyAttribute = parseAnyAttribute(child);
+			break;
+	}
+	return result;
+}
+function parseAttributeGroupRef(el) {
+	const result = { ref: "" };
+	copyAttr(el, result, "id");
+	copyAttr(el, result, "ref");
+	parseAnnotationChild(el, result);
+	return result;
+}
+function parseAny(el) {
+	const result = {};
+	copyAttr(el, result, "id");
+	copyAttr(el, result, "minOccurs");
+	copyAttr(el, result, "maxOccurs");
+	copyAttr(el, result, "namespace");
+	copyAttr(el, result, "processContents");
+	copyAttr(el, result, "notNamespace");
+	copyAttr(el, result, "notQName");
+	parseAnnotationChild(el, result);
+	return result;
+}
+function parseAnyAttribute(el) {
+	const result = {};
+	copyAttr(el, result, "id");
+	copyAttr(el, result, "namespace");
+	copyAttr(el, result, "processContents");
+	copyAttr(el, result, "notNamespace");
+	copyAttr(el, result, "notQName");
+	parseAnnotationChild(el, result);
+	return result;
+}
+function parseUnique(el) {
+	const result = { name: "" };
+	copyAttr(el, result, "id");
+	copyAttr(el, result, "name");
+	copyAttr(el, result, "ref");
+	parseAnnotationChild(el, result);
+	for (const child of getAllChildElements(el)) {
+		const name = getLocalName(child);
+		if (name === "selector") result.selector = parseSelector(child);
+		else if (name === "field") pushTo(result, "field", parseField(child));
+	}
+	return result;
+}
+function parseKey(el) {
+	const result = { name: "" };
+	copyAttr(el, result, "id");
+	copyAttr(el, result, "name");
+	copyAttr(el, result, "ref");
+	parseAnnotationChild(el, result);
+	for (const child of getAllChildElements(el)) {
+		const name = getLocalName(child);
+		if (name === "selector") result.selector = parseSelector(child);
+		else if (name === "field") pushTo(result, "field", parseField(child));
+	}
+	return result;
+}
+function parseKeyref(el) {
+	const result = {
+		name: "",
+		refer: ""
+	};
+	copyAttr(el, result, "id");
+	copyAttr(el, result, "name");
+	copyAttr(el, result, "ref");
+	copyAttr(el, result, "refer");
+	parseAnnotationChild(el, result);
+	for (const child of getAllChildElements(el)) {
+		const name = getLocalName(child);
+		if (name === "selector") result.selector = parseSelector(child);
+		else if (name === "field") pushTo(result, "field", parseField(child));
+	}
+	return result;
+}
+function parseSelector(el) {
+	const result = { xpath: "" };
+	copyAttr(el, result, "id");
+	copyAttr(el, result, "xpath");
+	copyAttr(el, result, "xpathDefaultNamespace");
+	parseAnnotationChild(el, result);
+	return result;
+}
+function parseField(el) {
+	const result = { xpath: "" };
+	copyAttr(el, result, "id");
+	copyAttr(el, result, "xpath");
+	copyAttr(el, result, "xpathDefaultNamespace");
+	parseAnnotationChild(el, result);
+	return result;
+}
+function parseOpenContent(el) {
+	const result = {};
+	copyAttr(el, result, "id");
+	copyAttr(el, result, "mode");
+	parseAnnotationChild(el, result);
+	for (const child of getAllChildElements(el)) if (getLocalName(child) === "any") result.any = parseAny(child);
+	return result;
+}
+function parseDefaultOpenContent(el) {
+	const result = { any: {} };
+	copyAttr(el, result, "id");
+	copyBoolAttr(el, result, "appliesToEmpty");
+	copyAttr(el, result, "mode");
+	parseAnnotationChild(el, result);
+	for (const child of getAllChildElements(el)) if (getLocalName(child) === "any") result.any = parseAny(child);
+	return result;
+}
+function parseAssertion(el) {
+	const result = {};
+	copyAttr(el, result, "id");
+	copyAttr(el, result, "test");
+	copyAttr(el, result, "xpathDefaultNamespace");
+	parseAnnotationChild(el, result);
+	return result;
+}
+function parseAlternative(el) {
+	const result = {};
+	copyAttr(el, result, "id");
+	copyAttr(el, result, "test");
+	copyAttr(el, result, "type");
+	copyAttr(el, result, "xpathDefaultNamespace");
+	parseAnnotationChild(el, result);
+	for (const child of getAllChildElements(el)) {
+		const name = getLocalName(child);
+		if (name === "simpleType") result.simpleType = parseLocalSimpleType(child);
+		else if (name === "complexType") result.complexType = parseLocalComplexType(child);
+	}
+	return result;
+}
+function parseNotation(el) {
+	const result = {
+		name: "",
+		public: ""
+	};
+	copyAttr(el, result, "id");
+	copyAttr(el, result, "name");
+	copyAttr(el, result, "public");
+	copyAttr(el, result, "system");
+	parseAnnotationChild(el, result);
+	return result;
+}
+function copyAttr(el, target, name) {
+	if (el.hasAttribute(name)) {
+		const value = el.getAttribute(name);
+		if (value !== null) target[name] = value;
+	}
+}
+function copyBoolAttr(el, target, name) {
+	if (el.hasAttribute(name)) {
+		const value = el.getAttribute(name);
+		if (value !== null) target[name] = value === "true";
+	}
+}
+function pushTo(target, name, value) {
+	if (!target[name]) target[name] = [];
+	target[name].push(value);
+}
+function parseAnnotationChild(el, result) {
+	for (const child of getAllChildElements(el)) if (getLocalName(child) === "annotation") {
+		result.annotation = parseAnnotation(child);
+		break;
+	}
+}
+/**
+* Extract xmlns declarations from an element's attributes.
+* Returns undefined if no xmlns declarations found.
+*
+* @example
+* For <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:tns="http://example.com">
+* Returns: { xs: "http://www.w3.org/2001/XMLSchema", tns: "http://example.com" }
+*
+* For <xs:element xmlns="http://default.com">
+* Returns: { "": "http://default.com" }
+*/
+function extractXmlns(el) {
+	const xmlns = {};
+	let hasXmlns = false;
+	for (let i = 0; i < el.attributes.length; i++) {
+		const attr = el.attributes[i];
+		const name = attr.name;
+		const value = attr.value;
+		if (name === "xmlns") {
+			xmlns[""] = value;
+			hasXmlns = true;
+		} else if (name.startsWith("xmlns:")) {
+			const prefix = name.substring(6);
+			xmlns[prefix] = value;
+			hasXmlns = true;
+		}
+	}
+	return hasXmlns ? xmlns : void 0;
+}
+/**
+* Copy xmlns declarations to target if present
+*/
+function copyXmlns(el, target) {
+	const xmlns = extractXmlns(el);
+	if (xmlns) target.$xmlns = xmlns;
+}
+
+//#endregion
+//#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(`${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(`${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(`${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(`${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(`${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(`${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(`${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(`${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(`${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(`${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(`${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(`${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(`${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(`${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(`${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(`${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(`${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(`${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(`${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(`${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(`${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(`${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(`${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(`${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(`${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(`${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(`${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(`${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(`${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(`${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(`${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(`${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(`${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(f, childCtx));
+	return buildElement(`${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(f, childCtx));
+	return buildElement(`${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(f, childCtx));
+	return buildElement(`${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(`${ctx.prefix}:selector`, attrs, children, ctx);
+}
+function buildField(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(`${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(`${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(`${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(`${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(`${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(`${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(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/xsd/traverser.ts
+/**
+* Base class for OO schema traversal using real W3C XSD types.
+*
+* Subclass and override the `on*` methods you need.
+* Context is available via `this` - no parameter passing needed.
+*/
+var SchemaTraverser = class {
+	/** Root schema being traversed */
+	rootSchema;
+	/** Current schema being visited */
+	currentSchema;
+	/** Source of current node (direct, redefine, override, include, import) */
+	source = "direct";
+	/** Depth in schema hierarchy (0 = root) */
+	depth = 0;
+	/** Traversal options */
+	options = {
+		includeImports: true,
+		includeIncludes: true,
+		maxDepth: Infinity
+	};
+	/** Visited schemas (prevents infinite loops) */
+	visited = /* @__PURE__ */ new Set();
+	/**
+	* Traverse a schema and all its imports/includes.
+	* Override `on*` methods to handle specific node types.
+	*/
+	traverse(schema, options = {}) {
+		this.rootSchema = schema;
+		this.options = {
+			...this.options,
+			...options
+		};
+		this.visited.clear();
+		this.traverseSchema(schema, "direct", 0);
+		return this;
+	}
+	/** Called when entering a schema */
+	onEnterSchema(_schema) {}
+	/** Called when leaving a schema */
+	onLeaveSchema(_schema) {}
+	/** Called for each top-level complexType */
+	onComplexType(_ct) {}
+	/** Called for each top-level simpleType */
+	onSimpleType(_st) {}
+	/** Called for each top-level element */
+	onElement(_element) {}
+	/** Called for each top-level attribute */
+	onAttribute(_attr) {}
+	/** Called for each named group */
+	onGroup(_group) {}
+	/** Called for each named attributeGroup */
+	onAttributeGroup(_group) {}
+	/** Called for each redefine block */
+	onRedefine(_redefine) {}
+	/** Called for each override block */
+	onOverride(_override) {}
+	traverseSchema(schema, source, depth) {
+		if (this.visited.has(schema)) return;
+		if (depth > this.options.maxDepth) return;
+		this.visited.add(schema);
+		this.currentSchema = schema;
+		this.source = source;
+		this.depth = depth;
+		this.onEnterSchema(schema);
+		this.traverseSchemaChildren(schema);
+		this.traverseRedefines(schema);
+		this.traverseOverrides(schema);
+		this.traverseIncludes(schema, depth);
+		this.traverseImports(schema, depth);
+		this.onLeaveSchema(schema);
+	}
+	traverseSchemaChildren(schema) {
+		if (schema.complexType) for (const ct of schema.complexType) this.onComplexType(ct);
+		if (schema.simpleType) for (const st of schema.simpleType) this.onSimpleType(st);
+		if (schema.element) for (const element of schema.element) this.onElement(element);
+		if (schema.attribute) for (const attr of schema.attribute) this.onAttribute(attr);
+		if (schema.group) for (const group of schema.group) this.onGroup(group);
+		if (schema.attributeGroup) for (const group of schema.attributeGroup) this.onAttributeGroup(group);
+	}
+	traverseRedefines(schema) {
+		if (!schema.redefine) return;
+		const prevSource = this.source;
+		this.source = "redefine";
+		for (const redefine of schema.redefine) {
+			this.onRedefine(redefine);
+			if (redefine.complexType) for (const ct of redefine.complexType) this.onComplexType(ct);
+			if (redefine.simpleType) for (const st of redefine.simpleType) this.onSimpleType(st);
+			if (redefine.group) for (const group of redefine.group) this.onGroup(group);
+			if (redefine.attributeGroup) for (const group of redefine.attributeGroup) this.onAttributeGroup(group);
+		}
+		this.source = prevSource;
+	}
+	traverseOverrides(schema) {
+		if (!schema.override) return;
+		const prevSource = this.source;
+		this.source = "override";
+		for (const override of schema.override) {
+			this.onOverride(override);
+			if (override.complexType) for (const ct of override.complexType) this.onComplexType(ct);
+			if (override.simpleType) for (const st of override.simpleType) this.onSimpleType(st);
+			if (override.element) for (const element of override.element) this.onElement(element);
+			if (override.attribute) for (const attr of override.attribute) this.onAttribute(attr);
+			if (override.group) for (const group of override.group) this.onGroup(group);
+			if (override.attributeGroup) for (const group of override.attributeGroup) this.onAttributeGroup(group);
+		}
+		this.source = prevSource;
+	}
+	traverseIncludes(schema, depth) {
+		if (!this.options.includeIncludes || !schema.$includes) return;
+		for (const included of schema.$includes) this.traverseSchema(included, "include", depth + 1);
+	}
+	traverseImports(schema, depth) {
+		if (!this.options.includeImports || !schema.$imports) return;
+		for (const imported of schema.$imports) this.traverseSchema(imported, "import", depth + 1);
+	}
+};
+/**
+* Resolves a schema hierarchy into a flat structure.
+* All types are collected into Maps for O(1) lookup.
+*
+* Precedence rules:
+* - redefine/override types take precedence over original
+* - root schema types take precedence over imported/included
+*/
+var SchemaResolver = class extends SchemaTraverser {
+	complexTypes = /* @__PURE__ */ new Map();
+	simpleTypes = /* @__PURE__ */ new Map();
+	elements = /* @__PURE__ */ new Map();
+	attributes = /* @__PURE__ */ new Map();
+	groups = /* @__PURE__ */ new Map();
+	attributeGroups = /* @__PURE__ */ new Map();
+	xmlns = /* @__PURE__ */ new Map();
+	substitutionGroups = /* @__PURE__ */ new Map();
+	/** Get the resolved schema structure */
+	getResolved() {
+		return {
+			complexTypes: this.complexTypes,
+			simpleTypes: this.simpleTypes,
+			elements: this.elements,
+			attributes: this.attributes,
+			groups: this.groups,
+			attributeGroups: this.attributeGroups,
+			xmlns: this.xmlns,
+			substitutionGroups: this.substitutionGroups
+		};
+	}
+	onEnterSchema(schema) {
+		if (schema.$xmlns) {
+			for (const [prefix, uri] of Object.entries(schema.$xmlns)) if (!this.xmlns.has(prefix)) this.xmlns.set(prefix, uri);
+		}
+	}
+	onComplexType(ct) {
+		if (!this.complexTypes.has(ct.name) || this.source === "redefine" || this.source === "override" || this.depth === 0 && this.source === "direct") this.complexTypes.set(ct.name, {
+			ct,
+			schema: this.currentSchema
+		});
+	}
+	onSimpleType(st) {
+		if (!this.simpleTypes.has(st.name) || this.source === "redefine" || this.source === "override" || this.depth === 0 && this.source === "direct") this.simpleTypes.set(st.name, {
+			st,
+			schema: this.currentSchema
+		});
+	}
+	onElement(element) {
+		if (!this.elements.has(element.name) || this.source === "override" || this.depth === 0 && this.source === "direct") this.elements.set(element.name, {
+			element,
+			schema: this.currentSchema
+		});
+		if (element.substitutionGroup) {
+			const abstractName = stripNsPrefix(element.substitutionGroup);
+			const existing = this.substitutionGroups.get(abstractName) ?? [];
+			existing.push(element);
+			this.substitutionGroups.set(abstractName, existing);
+		}
+	}
+	onAttribute(attr) {
+		if (!this.attributes.has(attr.name) || this.source === "override" || this.depth === 0 && this.source === "direct") this.attributes.set(attr.name, {
+			attr,
+			schema: this.currentSchema
+		});
+	}
+	onGroup(group) {
+		if (!this.groups.has(group.name) || this.source === "redefine" || this.source === "override" || this.depth === 0 && this.source === "direct") this.groups.set(group.name, {
+			group,
+			schema: this.currentSchema
+		});
+	}
+	onAttributeGroup(group) {
+		if (!this.attributeGroups.has(group.name) || this.source === "redefine" || this.source === "override" || this.depth === 0 && this.source === "direct") this.attributeGroups.set(group.name, {
+			group,
+			schema: this.currentSchema
+		});
+	}
+};
+/**
+* Strip namespace prefix from a QName (e.g., "xs:string" -> "string")
+*/
+function stripNsPrefix(qname) {
+	const colonIndex = qname.indexOf(":");
+	return colonIndex >= 0 ? qname.slice(colonIndex + 1) : qname;
+}
+/**
+* Resolve a schema hierarchy into a flat structure.
+* Convenience function that creates a SchemaResolver and returns the result.
+*/
+function resolveSchemaTypes(schema, options = {}) {
+	const resolver = new SchemaResolver();
+	resolver.traverse(schema, options);
+	return resolver.getResolved();
+}
+
+//#endregion
+//#region src/xsd/resolve.ts
+/**
+* Collects all schema components into Maps for resolution.
+*
+* IMPORTANT: Elements are only collected from schemas with the SAME targetNamespace
+* as the root schema. This follows XSD semantics where xs:import brings in types
+* from a different namespace but doesn't merge elements into the current namespace.
+*/
+var SchemaCollector = class extends SchemaTraverser {
+	complexTypes = /* @__PURE__ */ new Map();
+	simpleTypes = /* @__PURE__ */ new Map();
+	elements = /* @__PURE__ */ new Map();
+	groups = /* @__PURE__ */ new Map();
+	attributeGroups = /* @__PURE__ */ new Map();
+	substitutionGroups = /* @__PURE__ */ new Map();
+	xmlns = /* @__PURE__ */ new Map();
+	onEnterSchema(schema) {
+		if (schema.$xmlns) {
+			for (const [prefix, uri] of Object.entries(schema.$xmlns)) if (!this.xmlns.has(prefix)) this.xmlns.set(prefix, uri);
+		}
+	}
+	onComplexType(ct) {
+		if (!this.complexTypes.has(ct.name)) this.complexTypes.set(ct.name, ct);
+	}
+	onSimpleType(st) {
+		if (!this.simpleTypes.has(st.name)) this.simpleTypes.set(st.name, st);
+	}
+	onElement(element) {
+		const rootNs = this.rootSchema.targetNamespace;
+		const currentNs = this.currentSchema.targetNamespace;
+		const sameOrNoNamespace = currentNs === rootNs || !currentNs;
+		const hasSubstitutionGroup = !!element.substitutionGroup;
+		const isAbstract = !!element.abstract;
+		if ((sameOrNoNamespace || hasSubstitutionGroup || isAbstract) && !this.elements.has(element.name)) this.elements.set(element.name, element);
+		if (element.substitutionGroup) {
+			const abstractName = stripNsPrefix(element.substitutionGroup);
+			const existing = this.substitutionGroups.get(abstractName) ?? [];
+			existing.push(element);
+			this.substitutionGroups.set(abstractName, existing);
+		}
+	}
+	onGroup(group) {
+		if (!this.groups.has(group.name)) this.groups.set(group.name, group);
+	}
+	onAttributeGroup(group) {
+		if (!this.attributeGroups.has(group.name)) this.attributeGroups.set(group.name, group);
+	}
+};
+/**
+* Resolve a schema by merging all imports/includes and expanding all references.
+* Returns a new self-contained schema with no external dependencies.
+*/
+function resolveSchema(schema, options = {}) {
+	const { resolveImports = true, resolveIncludes = true, expandExtensions = true, expandSubstitutions = true, filterToRootElements = false, keepImportsRef = false } = options;
+	const collector = new SchemaCollector();
+	collector.traverse(schema, {
+		includeImports: resolveImports,
+		includeIncludes: resolveIncludes
+	});
+	let elements;
+	if (filterToRootElements) {
+		const referencedElements = /* @__PURE__ */ new Set();
+		for (const el of collector.elements.values()) collectElementRefs(el, referencedElements);
+		for (const ct of collector.complexTypes.values()) collectElementRefsFromType(ct, referencedElements);
+		elements = Array.from(collector.elements.values()).filter((el) => {
+			if (el.abstract === true) return false;
+			if (referencedElements.has(el.name)) return false;
+			return true;
+		});
+	} else elements = Array.from(collector.elements.values());
+	let resolvedComplexTypes = Array.from(collector.complexTypes.values());
+	if (expandExtensions) resolvedComplexTypes = resolvedComplexTypes.map((ct) => expandComplexTypeExtension(ct, collector.complexTypes));
+	if (expandSubstitutions) resolvedComplexTypes = resolvedComplexTypes.map((ct) => expandSubstitutionGroupsInType(ct, collector.elements, collector.substitutionGroups));
+	const resolved = {
+		targetNamespace: schema.targetNamespace,
+		elementFormDefault: schema.elementFormDefault,
+		$filename: schema.$filename,
+		$xmlns: collector.xmlns.size > 0 ? Object.fromEntries(collector.xmlns) : schema.$xmlns
+	};
+	if (elements.length > 0) resolved.element = elements;
+	if (resolvedComplexTypes.length > 0) resolved.complexType = resolvedComplexTypes;
+	if (collector.simpleTypes.size > 0) resolved.simpleType = Array.from(collector.simpleTypes.values());
+	if (collector.groups.size > 0) resolved.group = Array.from(collector.groups.values());
+	if (collector.attributeGroups.size > 0) resolved.attributeGroup = Array.from(collector.attributeGroups.values());
+	if (keepImportsRef && schema.$imports) resolved.$imports = schema.$imports;
+	return resolved;
+}
+/**
+* Expand complexContent/extension by merging base type properties.
+* Uses a visited set to prevent infinite recursion on circular inheritance.
+*/
+function expandComplexTypeExtension(ct, allTypes, visited = /* @__PURE__ */ new Set()) {
+	const extension = ct.complexContent?.extension;
+	if (!extension?.base) return ct;
+	if (visited.has(ct.name)) return ct;
+	visited.add(ct.name);
+	const mergedElements = [];
+	const mergedAttributes = [];
+	const baseName = stripNsPrefix(extension.base);
+	const baseType = allTypes.get(baseName);
+	if (baseType && !visited.has(baseName)) {
+		const expandedBase = expandComplexTypeExtension(baseType, allTypes, visited);
+		collectElementsFromType(expandedBase, mergedElements);
+		if (expandedBase.attribute) mergedAttributes.push(...expandedBase.attribute);
+	}
+	collectElementsFromGroup(extension.sequence, mergedElements);
+	collectElementsFromGroup(extension.choice, mergedElements);
+	collectElementsFromGroup(extension.all, mergedElements);
+	if (extension.attribute) mergedAttributes.push(...extension.attribute);
+	const flattened = { name: ct.name };
+	if (mergedElements.length > 0) flattened.all = { element: mergedElements };
+	if (mergedAttributes.length > 0) flattened.attribute = mergedAttributes;
+	for (const [key, value] of Object.entries(ct)) if (![
+		"name",
+		"complexContent",
+		"all",
+		"sequence",
+		"choice",
+		"attribute"
+	].includes(key)) flattened[key] = value;
+	return flattened;
+}
+/**
+* Collect elements from a complex type's content model.
+*/
+function collectElementsFromType(ct, elements) {
+	collectElementsFromGroup(ct.sequence, elements);
+	collectElementsFromGroup(ct.choice, elements);
+	collectElementsFromGroup(ct.all, elements);
+}
+/**
+* Collect elements from a group (sequence/choice/all).
+*/
+function collectElementsFromGroup(group, elements) {
+	if (!group?.element) return;
+	elements.push(...group.element);
+}
+/**
+* Expand substitution group references in a complex type.
+* Replaces abstract element refs with concrete substitute elements.
+*/
+function expandSubstitutionGroupsInType(ct, allElements, substitutionGroups) {
+	let changed = false;
+	const result = { ...ct };
+	if (ct.sequence) {
+		const expanded = expandSubstitutionGroupsInGroup(ct.sequence, allElements, substitutionGroups);
+		if (expanded !== ct.sequence) {
+			result.sequence = expanded;
+			changed = true;
+		}
+	}
+	if (ct.all) {
+		const expanded = expandSubstitutionGroupsInGroup(ct.all, allElements, substitutionGroups);
+		if (expanded !== ct.all) {
+			result.all = expanded;
+			changed = true;
+		}
+	}
+	if (ct.choice) {
+		const expanded = expandSubstitutionGroupsInGroup(ct.choice, allElements, substitutionGroups);
+		if (expanded !== ct.choice) {
+			result.choice = expanded;
+			changed = true;
+		}
+	}
+	return changed ? result : ct;
+}
+/**
+* Expand substitution groups in a group (sequence/all/choice).
+*/
+function expandSubstitutionGroupsInGroup(group, allElements, substitutionGroups) {
+	if (!group.element) return group;
+	const expandedElements = [];
+	let hasChanges = false;
+	for (const el of group.element) {
+		if (el.ref) {
+			const refName = stripNsPrefix(el.ref);
+			if (allElements.get(refName)?.abstract) {
+				const substitutes = substitutionGroups.get(refName);
+				if (substitutes && substitutes.length > 0) {
+					for (const sub of substitutes) expandedElements.push({
+						name: sub.name,
+						type: sub.type,
+						minOccurs: el.minOccurs ?? 0,
+						maxOccurs: el.maxOccurs
+					});
+					hasChanges = true;
+					continue;
+				}
+			}
+		}
+		expandedElements.push(el);
+	}
+	if (!hasChanges) return group;
+	return {
+		...group,
+		element: expandedElements
+	};
+}
+/**
+* Get all substitutes for an abstract element.
+*/
+function getSubstitutes(abstractElementName, schema) {
+	const collector = new SchemaCollector();
+	collector.traverse(schema);
+	return collector.substitutionGroups.get(abstractElementName) ?? [];
+}
+/**
+* Collect element refs from an element's nested structure
+*/
+function collectElementRefs(el, refs) {
+	const record = el;
+	if (record.complexType) collectElementRefsFromType(record.complexType, refs);
+}
+/**
+* Recursively collect element refs from a complex type
+*/
+function collectElementRefsFromType(ct, refs) {
+	const record = ct;
+	for (const groupKey of [
+		"sequence",
+		"all",
+		"choice"
+	]) {
+		const group = record[groupKey];
+		if (group?.element) {
+			const elements = group.element;
+			for (const el of elements) {
+				if (el.ref) {
+					const refName = stripNsPrefix(el.ref);
+					refs.add(refName);
+				}
+				if (el.complexType) collectElementRefsFromType(el.complexType, refs);
+			}
+		}
+	}
+	if (record.complexContent) {
+		const cc = record.complexContent;
+		if (cc.extension) collectElementRefsFromType(cc.extension, refs);
+	}
+}
+
+//#endregion
+//#region src/xsd/loader.ts
+/**
+* Schema Loader - Load and parse XSD files from disk
+*
+* Simple loader that reads XSD files and parses them into Schema objects.
+* Resolution of imports/includes is handled by the resolver.
+*/
+/**
+* Default XSD loader - reads from filesystem
+*/
+function defaultLoader(schemaLocation, basePath) {
+	const fullPath = resolve(basePath, schemaLocation);
+	if (!existsSync(fullPath)) return null;
+	return readFileSync(fullPath, "utf-8");
+}
+/**
+* Load and parse a single XSD file.
+*
+* @param schemaPath - Path to the XSD file
+* @param options - Loader options
+* @param options.autoLink - Populate $imports/$includes with loaded schemas (preserves structure)
+* @param options.autoResolve - Flatten into single schema with all types merged (implies autoLink)
+* @returns Parsed schema
+*
+* @example
+* ```typescript
+* // Just parse - no linking
+* const schema = loadSchema('/path/to/schema.xsd');
+*
+* // Link - populate $imports/$includes (preserves multi-schema structure)
+* const linked = loadSchema('/path/to/schema.xsd', { autoLink: true });
+* // linked.$imports contains actual Schema objects
+*
+* // Resolve - flatten everything into one schema
+* const resolved = loadSchema('/path/to/schema.xsd', { autoResolve: true });
+* // resolved has all types merged, no $imports/$includes
+* ```
+*/
+function loadSchema(schemaPath, options = {}) {
+	const { basePath = dirname(schemaPath), loader = defaultLoader, autoLink = false, autoResolve = false, throwOnMissing = false } = options;
+	const content = loader(schemaPath, basePath);
+	if (!content) throw new Error(`Failed to load schema: ${schemaPath}`);
+	let schema = parseXsd(content);
+	Object.assign(schema, { $filename: schemaPath });
+	if (autoLink || autoResolve) linkSchema(schema, {
+		basePath,
+		loader,
+		throwOnMissing
+	});
+	if (autoResolve) schema = resolveSchema(schema);
+	return schema;
+}
+/**
+* Load and parse XSD content from a string.
+*/
+function parseSchemaContent(content, filename) {
+	const schema = parseXsd(content);
+	if (filename) Object.assign(schema, { $filename: filename });
+	return schema;
+}
+/**
+* Create a schema loader function that can be passed to the resolver.
+* The resolver will call this to load schemas referenced by schemaLocation.
+*/
+function createSchemaLoader(basePath, loader = defaultLoader) {
+	const cache = /* @__PURE__ */ new Map();
+	return (schemaLocation) => {
+		const fullPath = resolve(basePath, schemaLocation);
+		const cached = cache.get(fullPath);
+		if (cached) return cached;
+		const content = loader(schemaLocation, basePath);
+		if (!content) return null;
+		const schema = parseXsd(content);
+		Object.assign(schema, { $filename: schemaLocation });
+		cache.set(fullPath, schema);
+		return schema;
+	};
+}
+/**
+* Link a schema by resolving all schemaLocation references.
+*
+* Processes:
+* - xs:import → populates $imports
+* - xs:include → populates $includes
+* - xs:redefine → loads base schema, keeps redefinitions in redefine array
+* - xs:override → loads base schema, keeps overrides in override array
+*
+* @param schema - Schema to link (will be mutated with $imports/$includes)
+* @param options - Link options including basePath for resolving paths
+* @returns The same schema with $imports and $includes populated
+*
+* @example
+* ```typescript
+* const schema = parseXsd(xsdContent);
+* linkSchema(schema, { basePath: '/path/to/xsd/files' });
+* // schema.$imports and schema.$includes are now populated
+* ```
+*/
+function linkSchema(schema, options) {
+	const { basePath, loader = defaultLoader, throwOnMissing = true } = options;
+	const cache = /* @__PURE__ */ new Map();
+	const inProgress = /* @__PURE__ */ new Set();
+	const loadAndLink = (schemaLocation, currentBasePath) => {
+		const fullPath = resolve(currentBasePath, schemaLocation);
+		const cached = cache.get(fullPath);
+		if (cached) return cached;
+		if (inProgress.has(fullPath)) return cache.get(fullPath) ?? null;
+		const content = loader(schemaLocation, currentBasePath);
+		if (!content) {
+			if (throwOnMissing) throw new Error(`Failed to load schema: ${schemaLocation} (resolved: ${fullPath})`);
+			return null;
+		}
+		const loadedSchema = parseXsd(content);
+		Object.assign(loadedSchema, { $filename: schemaLocation });
+		inProgress.add(fullPath);
+		cache.set(fullPath, loadedSchema);
+		linkSchemaInternal(loadedSchema, dirname(fullPath));
+		inProgress.delete(fullPath);
+		return loadedSchema;
+	};
+	const linkSchemaInternal = (s, currentBasePath) => {
+		const imports = [];
+		const includes = [];
+		if (s.import) {
+			for (const imp of s.import) if (imp.schemaLocation) {
+				const linked = loadAndLink(imp.schemaLocation, currentBasePath);
+				if (linked) imports.push(linked);
+			}
+		}
+		if (s.include) {
+			for (const inc of s.include) if (inc.schemaLocation) {
+				const linked = loadAndLink(inc.schemaLocation, currentBasePath);
+				if (linked) includes.push(linked);
+			}
+		}
+		if (s.redefine) {
+			for (const redef of s.redefine) if (redef.schemaLocation) {
+				const linked = loadAndLink(redef.schemaLocation, currentBasePath);
+				if (linked) Object.assign(redef, { $schema: linked });
+			}
+		}
+		if (s.override) {
+			for (const ovr of s.override) if (ovr.schemaLocation) {
+				const linked = loadAndLink(ovr.schemaLocation, currentBasePath);
+				if (linked) Object.assign(ovr, { $schema: linked });
+			}
+		}
+		if (imports.length > 0) Object.assign(s, { $imports: imports });
+		if (includes.length > 0) Object.assign(s, { $includes: includes });
+	};
+	linkSchemaInternal(schema, basePath);
+	return schema;
+}
+/**
+* Load and link a schema from a file path.
+* Convenience function that combines loadSchema + linkSchema.
+*
+* @param schemaPath - Path to the XSD file
+* @param options - Optional loader options
+* @returns Fully linked schema with $imports and $includes populated
+*
+* @example
+* ```typescript
+* const schema = loadAndLinkSchema('/path/to/schema.xsd');
+* // schema.$imports and schema.$includes are populated
+* // Ready for type inference or resolution
+* ```
+*/
+function loadAndLinkSchema(schemaPath, options = {}) {
+	const basePath = dirname(schemaPath);
+	return linkSchema(loadSchema(schemaPath, {
+		...options,
+		basePath
+	}), {
+		basePath,
+		loader: options.loader
+	});
+}
+
+//#endregion
+//#region src/codegen/runner.ts
+/**
+* Config Runner
+*
+* Executes the generator pipeline based on configuration.
+*/
+/**
+* Run the codegen pipeline
+*/
+async function runCodegen(config, options) {
+	const { rootDir, dryRun = false, verbose = false } = options;
+	const result = {
+		files: [],
+		schemas: [],
+		errors: []
+	};
+	const log = verbose ? console.log.bind(console) : () => {};
+	const sources = {};
+	for (const [name, sourceConfig] of Object.entries(config.sources)) {
+		const xsdDir = isAbsolute(sourceConfig.xsdDir) ? sourceConfig.xsdDir : join(rootDir, sourceConfig.xsdDir);
+		let schemas = sourceConfig.schemas;
+		if (sourceConfig.autoLink) schemas = discoverDependentSchemas(sourceConfig.schemas, xsdDir, log);
+		sources[name] = {
+			name,
+			xsdDir,
+			outputDir: isAbsolute(sourceConfig.outputDir) ? sourceConfig.outputDir : join(rootDir, sourceConfig.outputDir),
+			schemas
+		};
+	}
+	const setupCtx = {
+		sources,
+		rootDir
+	};
+	if (config.clean) {
+		log(`\n🧹 Cleaning output directories...`);
+		for (const source of Object.values(sources)) if (existsSync(source.outputDir)) {
+			rmSync(source.outputDir, {
+				recursive: true,
+				force: true
+			});
+			log(`  ✅ Cleaned ${relative(rootDir, source.outputDir)}`);
+		}
+	}
+	if (config.beforeAll) {
+		log(`\n🔧 Running beforeAll hook...`);
+		await config.beforeAll({
+			sources,
+			rootDir
+		});
+	}
+	for (const generator of config.generators) if (generator.setup) {
+		log(`[${generator.name}] Running setup...`);
+		await generator.setup(setupCtx);
+	}
+	const processedSchemas = /* @__PURE__ */ new Map();
+	const globalAllSchemas = /* @__PURE__ */ new Map();
+	/**
+	* Recursively discover and parse schemas referenced via xs:include or xs:redefine.
+	* This ensures schemas like types/devc.xsd are in globalAllSchemas when devc.xsd references them.
+	*
+	* @param schema - The parsed schema object
+	* @param xsdDir - The root XSD directory (e.g., '.xsd')
+	* @param currentXsdPath - The path of the current XSD file (for resolving relative paths)
+	* @param sourceName - The source name for logging
+	* @param discovered - Set of already discovered schema names
+	*/
+	function discoverReferencedSchemas(schema, xsdDir, currentXsdPath, sourceName, discovered = /* @__PURE__ */ new Set()) {
+		const includes = schema.include;
+		const redefines = schema.redefine;
+		const refs = [...includes ?? [], ...redefines ?? []];
+		for (const ref of refs) {
+			if (!ref.schemaLocation) continue;
+			const schemaNameWithPath = ref.schemaLocation.replace(/\.xsd$/, "");
+			if (discovered.has(schemaNameWithPath) || globalAllSchemas.has(schemaNameWithPath)) continue;
+			discovered.add(schemaNameWithPath);
+			const currentXsdDir = dirname(currentXsdPath);
+			const refXsdPath = join(currentXsdDir, ref.schemaLocation);
+			if (!existsSync(refXsdPath)) {
+				log(`    ⚠️  Referenced schema not found: ${ref.schemaLocation} (resolved from ${currentXsdDir})`);
+				continue;
+			}
+			try {
+				const refXsdContent = readFileSync(refXsdPath, "utf-8");
+				const refSchema = parseXsd(refXsdContent);
+				refSchema.$filename = ref.schemaLocation;
+				const refSchemaInfo = {
+					name: schemaNameWithPath,
+					xsdContent: refXsdContent,
+					schema: refSchema,
+					sourceName,
+					xsdPath: refXsdPath
+				};
+				globalAllSchemas.set(schemaNameWithPath, refSchemaInfo);
+				log(`    📎 Auto-discovered: ${schemaNameWithPath}`);
+				discoverReferencedSchemas(refSchema, xsdDir, refXsdPath, sourceName, discovered);
+			} catch (error) {
+				const err = error instanceof Error ? error : new Error(String(error));
+				log(`    ⚠️  Failed to parse referenced schema ${ref.schemaLocation}: ${err.message}`);
+			}
+		}
+	}
+	for (const [sourceName, source] of Object.entries(sources)) {
+		log(`\n📦 Processing source: ${sourceName}`);
+		const schemaInfos = [];
+		for (const schemaName of source.schemas) {
+			const xsdPath = join(source.xsdDir, `${schemaName}.xsd`);
+			if (!existsSync(xsdPath)) {
+				log(`  ⚠️  Skipping ${schemaName} - XSD not found`);
+				continue;
+			}
+			try {
+				const xsdContent = readFileSync(xsdPath, "utf-8");
+				const schema = parseXsd(xsdContent);
+				schema.$filename = `${schemaName}.xsd`;
+				linkSchema(schema, {
+					basePath: dirname(xsdPath),
+					throwOnMissing: false
+				});
+				const schemaInfo = {
+					name: schemaName,
+					xsdContent,
+					schema,
+					sourceName,
+					xsdPath
+				};
+				schemaInfos.push(schemaInfo);
+				globalAllSchemas.set(schemaName, schemaInfo);
+				result.schemas.push({
+					name: schemaName,
+					source: sourceName
+				});
+				discoverReferencedSchemas(schema, source.xsdDir, xsdPath, sourceName);
+			} catch (error) {
+				const err = error instanceof Error ? error : new Error(String(error));
+				log(`  ❌ Failed to parse ${schemaName}: ${err.message}`);
+				result.errors.push({
+					schema: schemaName,
+					source: sourceName,
+					error: err
+				});
+			}
+		}
+		processedSchemas.set(sourceName, schemaInfos);
+	}
+	for (const [sourceName, source] of Object.entries(sources)) {
+		const schemaInfos = processedSchemas.get(sourceName) ?? [];
+		for (const schemaInfo of schemaInfos) {
+			const transformCtx = {
+				schema: schemaInfo,
+				source,
+				allSchemas: globalAllSchemas,
+				allSources: sources,
+				rootDir,
+				resolveImport: createImportResolver(schemaInfo, source, sources, config)
+			};
+			for (const generator of config.generators) if (generator.transform) try {
+				const files = await generator.transform(transformCtx);
+				for (const file of files) {
+					const fullPath = join(source.outputDir, file.path);
+					if (!dryRun) {
+						mkdirSync(dirname(fullPath), { recursive: true });
+						writeFileSync(fullPath, file.content);
+					}
+					result.files.push({
+						path: fullPath,
+						source: sourceName
+					});
+					log(`  ✅ [${generator.name}] Generated ${file.path}`);
+				}
+			} catch (error) {
+				const err = error instanceof Error ? error : new Error(String(error));
+				log(`  ❌ [${generator.name}] Failed ${schemaInfo.name}: ${err.message}`);
+				result.errors.push({
+					schema: schemaInfo.name,
+					source: sourceName,
+					error: err
+				});
+			}
+		}
+	}
+	const finalizeCtx = {
+		processedSchemas,
+		sources,
+		rootDir
+	};
+	for (const generator of config.generators) if (generator.finalize) try {
+		log(`\n[${generator.name}] Running finalize...`);
+		const files = await generator.finalize(finalizeCtx);
+		for (const file of files) for (const [sourceName, source] of Object.entries(sources)) {
+			const fullPath = join(source.outputDir, file.path);
+			if (!dryRun) {
+				mkdirSync(dirname(fullPath), { recursive: true });
+				writeFileSync(fullPath, file.content);
+			}
+			result.files.push({
+				path: fullPath,
+				source: sourceName
+			});
+			log(`  ✅ [${generator.name}] Generated ${file.path} for ${sourceName}`);
+		}
+	} catch (error) {
+		const err = error instanceof Error ? error : new Error(String(error));
+		log(`  ❌ [${generator.name}] Finalize failed: ${err.message}`);
+		result.errors.push({ error: err });
+	}
+	if (config.afterAll) {
+		log(`\n🔧 Running afterAll hook...`);
+		const afterAllCtx = {
+			sources,
+			rootDir,
+			processedSchemas,
+			generatedFiles: result.files.map((f) => ({
+				path: f.path,
+				content: ""
+			}))
+		};
+		const extraFiles = await config.afterAll(afterAllCtx);
+		if (extraFiles && Array.isArray(extraFiles)) for (const file of extraFiles) {
+			const fullPath = join(rootDir, file.path);
+			if (!dryRun) {
+				mkdirSync(dirname(fullPath), { recursive: true });
+				writeFileSync(fullPath, file.content);
+			}
+			result.files.push({
+				path: fullPath,
+				source: "afterAll"
+			});
+			log(`  ✅ [afterAll] Generated ${file.path}`);
+		}
+	}
+	return result;
+}
+function createImportResolver(currentSchema, currentSource, allSources, config) {
+	const ext = config.importExtension ?? "";
+	return (schemaLocation) => {
+		const schemaPath = schemaLocation.replace(/\.xsd$/, "");
+		const schemaBaseName = schemaPath.replace(/^.*\//, "");
+		const currentSchemaDir = dirname(currentSchema.name);
+		const normalizedPath = (currentSchemaDir !== "." ? join(currentSchemaDir, schemaPath).replaceAll(/\\/g, "/") : schemaPath).split("/").reduce((acc, part) => {
+			if (part === "..") acc.pop();
+			else if (part !== ".") acc.push(part);
+			return acc;
+		}, []).join("/");
+		if (currentSource.schemas.includes(normalizedPath)) {
+			const fromDir = dirname(currentSchema.name);
+			const toPath = normalizedPath;
+			const relImport = fromDir === dirname(toPath) ? `./${basename(toPath)}${ext}` : relative(fromDir || ".", toPath).replaceAll(/\\/g, "/") || `./${basename(toPath)}`;
+			return relImport.startsWith(".") ? `${relImport}${ext}` : `./${relImport}${ext}`;
+		}
+		if (currentSource.schemas.includes(schemaPath)) return `./${schemaPath}${ext}`;
+		if (currentSource.schemas.includes(schemaBaseName)) return `./${schemaBaseName}${ext}`;
+		for (const [sourceName, source] of Object.entries(allSources)) {
+			if (sourceName === currentSource.name) continue;
+			if (source.schemas.includes(normalizedPath)) return `${relative(currentSource.outputDir, source.outputDir)}/${normalizedPath}${ext}`.replaceAll(/\\/g, "/");
+			if (source.schemas.includes(schemaPath)) return `${relative(currentSource.outputDir, source.outputDir)}/${schemaPath}${ext}`.replaceAll(/\\/g, "/");
+			if (source.schemas.includes(schemaBaseName)) return `${relative(currentSource.outputDir, source.outputDir)}/${schemaBaseName}${ext}`.replaceAll(/\\/g, "/");
+		}
+		return null;
+	};
+}
+/**
+* Discover all dependent schemas by recursively parsing XSD files
+* and extracting schemaLocation from xs:import, xs:include, xs:redefine
+*/
+function discoverDependentSchemas(entrySchemas, xsdDir, log) {
+	const discovered = /* @__PURE__ */ new Set();
+	const queue = [...entrySchemas];
+	while (queue.length > 0) {
+		const schemaName = queue.shift();
+		if (!schemaName) continue;
+		if (discovered.has(schemaName)) continue;
+		const xsdPath = join(xsdDir, `${schemaName}.xsd`);
+		if (!existsSync(xsdPath)) throw new Error(`Schema not found: ${schemaName}.xsd (resolved: ${xsdPath})`);
+		discovered.add(schemaName);
+		try {
+			const deps = extractSchemaLocations(parseXsd(readFileSync(xsdPath, "utf-8")), xsdDir, schemaName);
+			for (const dep of deps) if (!discovered.has(dep)) {
+				queue.push(dep);
+				log(`  🔗 Discovered dependency: ${dep} (from ${schemaName})`);
+			}
+		} catch {
+			log(`  ❌ Failed to parse ${schemaName} for dependency discovery`);
+		}
+	}
+	return Array.from(discovered);
+}
+/**
+* Extract schema names from schemaLocation attributes
+*/
+function extractSchemaLocations(schema, xsdDir, currentSchema) {
+	const locations = [];
+	const currentDir = dirname(join(xsdDir, `${currentSchema}.xsd`));
+	const imports = schema.import;
+	if (imports) {
+		for (const imp of imports) if (imp.schemaLocation) {
+			const name = resolveSchemaName(imp.schemaLocation, currentDir, xsdDir);
+			if (name) locations.push(name);
+		}
+	}
+	const includes = schema.include;
+	if (includes) {
+		for (const inc of includes) if (inc.schemaLocation) {
+			const name = resolveSchemaName(inc.schemaLocation, currentDir, xsdDir);
+			if (name) locations.push(name);
+		}
+	}
+	const redefines = schema.redefine;
+	if (redefines) {
+		for (const red of redefines) if (red.schemaLocation) {
+			const name = resolveSchemaName(red.schemaLocation, currentDir, xsdDir);
+			if (name) locations.push(name);
+		}
+	}
+	return locations;
+}
+/**
+* Resolve schemaLocation to a schema name relative to xsdDir
+*/
+function resolveSchemaName(schemaLocation, currentDir, xsdDir) {
+	const fullPath = join(currentDir, schemaLocation);
+	const name = relative(xsdDir, fullPath).replace(/\.xsd$/, "");
+	if (existsSync(fullPath)) return name;
+	return null;
+}
+
+//#endregion
+export { getAllChildElements as _, loadAndLinkSchema as a, getLocalName as b, getSubstitutes as c, SchemaTraverser as d, resolveSchemaTypes as f, parseXsd as g, buildXsd as h, linkSchema as i, resolveSchema as l, resolveImports as m, createSchemaLoader as n, loadSchema as o, linkSchemas as p, defaultLoader as r, parseSchemaContent as s, runCodegen as t, SchemaResolver as u, getAttributeValue as v, getTextContent as x, getChildElements as y };
+//# sourceMappingURL=runner-CRhT3smd.mjs.map