@abapify/ts-xsd 0.4.0 → 0.4.3

package/dist/runner-BSGqj8LM.mjs

@@ -0,0 +1,1822 @@
+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);
+	}
+	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));
+	}
+	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));
+	}
+	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));
+	}
+	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));
+	}
+	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));
+	}
+}
+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);
+	}
+}
+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));
+		}
+	}
+	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));
+		}
+	}
+	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));
+	}
+	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));
+	}
+	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));
+	}
+	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);
+	}
+	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);
+	}
+	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/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);
+		const newBasePath = dirname(fullPath);
+		linkSchemaInternal(loadedSchema, newBasePath);
+		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`;
+				const basePath = dirname(xsdPath);
+				linkSchema(schema, {
+					basePath,
+					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 xsdContent = readFileSync(xsdPath, "utf-8");
+			const deps = extractSchemaLocations(parseXsd(xsdContent), 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 { getLocalName as _, loadAndLinkSchema as a, getSubstitutes as c, SchemaTraverser as d, resolveSchemaTypes as f, getChildElements as g, getAttributeValue as h, linkSchema as i, resolveSchema as l, getAllChildElements as m, createSchemaLoader as n, loadSchema as o, parseXsd as p, defaultLoader as r, parseSchemaContent as s, runCodegen as t, SchemaResolver as u, getTextContent as v };
+//# sourceMappingURL=runner-BSGqj8LM.mjs.map