@abapify/ts-xsd 0.4.0 → 0.4.1

package/dist/index.d.mts

@@ -0,0 +1,1183 @@
+import { $ as Notation, A as ComplexContentExtension, B as Group, C as Any, D as Attribute, E as Assertion, F as Element, G as Keyref, H as Import, I as ExplicitGroup, J as LocalComplexType, K as List, L as Facet, M as ComplexType, N as DefaultOpenContent, O as AttributeGroupRef, P as Documentation, Q as NamedGroup, R as Field, S as Annotation, T as Appinfo, U as Include, V as GroupRef, W as Key, X as LocalSimpleType, Y as LocalElement, Z as NamedAttributeGroup, _ as TransformContext, _t as Union, a as getSubstitutes, at as Schema, b as Alternative, c as CodegenConfig, ct as SimpleContent, d as GeneratorPlugin, dt as SimpleType, et as OpenAttrs, f as HookContext, ft as SimpleTypeRestriction, g as SourceInfo, gt as TopLevelSimpleType, h as SourceConfig, ht as TopLevelElement, i as ResolveOptions, it as Redefine, j as ComplexContentRestriction, k as ComplexContent, l as FinalizeContext, lt as SimpleContentExtension, m as SetupContext, mt as TopLevelComplexType, n as RunnerResult, nt as Override, o as resolveSchema, ot as SchemaAttrs, p as SchemaInfo, pt as TopLevelAttribute, q as LocalAttribute, r as runCodegen, rt as Pattern, s as AfterAllContext, st as Selector, t as RunnerOptions, tt as OpenContent, u as GeneratedFile, ut as SimpleContentRestriction, v as defineConfig, vt as Unique, w as AnyAttribute, x as Annotated, y as All, yt as XmlnsDeclarations, z as FormChoice } from "./runner-C4_p2y5e.mjs";
+import { Project, SourceFile } from "ts-morph";
+
+//#region src/xsd/schema-like.d.ts
+/**
+ * Schema-Like Types for Type Inference
+ *
+ * These are minimal type constraints designed to work with `as const` schema literals.
+ * They are intentionally looser than the full W3C types in xsd/types.ts to allow
+ * TypeScript's compile-time type inference to work correctly.
+ *
+ * Key differences from xsd/types.ts:
+ * - All arrays are `readonly` for `as const` compatibility
+ * - Properties are optional and loosely typed
+ * - Designed for compile-time inference, not runtime validation
+ */
+/**
+ * Non-W3C extensions for schema composition and namespace handling.
+ * Properties prefixed with $ are clearly non-W3C.
+ */
+type SchemaExtensions = {
+  /**
+   * Namespace prefix declarations (xmlns:prefix -> namespace URI).
+   * Extracted from XML namespace attributes, not part of XSD spec.
+   * Prefixed with $ to indicate this is NOT a W3C XSD property.
+   */
+  readonly $xmlns?: {
+    readonly [prefix: string]: string;
+  };
+  /**
+   * Original filename/path of this schema.
+   * Used to reconstruct $imports relationships from schemaLocation references.
+   * Prefixed with $ to indicate this is NOT a W3C XSD property.
+   */
+  readonly $filename?: string;
+  /**
+   * Resolved imported schemas for cross-schema type resolution.
+   * Actual schema objects that can be searched for type definitions.
+   * Use this to link schemas that import each other (xs:import - different namespace).
+   */
+  readonly $imports?: readonly SchemaLike[];
+  /**
+   * Resolved included schemas for same-namespace type resolution.
+   * Content from xs:include is in the same namespace as the including schema.
+   * Walker traverses both $imports and $includes for type lookups.
+   */
+  readonly $includes?: readonly SchemaLike[];
+};
+/** Minimal schema shape for inference - W3C Schema properties plus extensions */
+type SchemaLike = SchemaExtensions & {
+  readonly targetNamespace?: string;
+  readonly elementFormDefault?: string;
+  readonly attributeFormDefault?: string;
+  readonly version?: string;
+  readonly id?: string;
+  readonly blockDefault?: string;
+  readonly finalDefault?: string;
+  readonly 'xml:lang'?: string;
+  readonly element?: readonly ElementLike[];
+  readonly complexType?: readonly ComplexTypeLike[] | {
+    readonly [name: string]: ComplexTypeLike;
+  };
+  readonly simpleType?: readonly SimpleTypeLike[] | {
+    readonly [name: string]: SimpleTypeLike;
+  };
+  readonly group?: readonly unknown[];
+  readonly attributeGroup?: readonly unknown[];
+  readonly notation?: readonly unknown[];
+  readonly annotation?: readonly unknown[];
+  readonly include?: readonly unknown[];
+  readonly import?: readonly unknown[];
+  readonly redefine?: readonly RedefineLike[];
+  readonly override?: readonly OverrideLike[];
+  readonly defaultOpenContent?: unknown;
+};
+type AnnotationLike = {
+  readonly documentation?: readonly unknown[];
+  readonly appinfo?: readonly unknown[];
+};
+type ElementLike = {
+  readonly name?: string;
+  readonly ref?: string;
+  readonly type?: string;
+  readonly minOccurs?: number | string;
+  readonly maxOccurs?: number | string | 'unbounded';
+  readonly default?: string;
+  readonly fixed?: string;
+  readonly id?: string;
+  readonly abstract?: boolean;
+  readonly nillable?: boolean;
+  readonly substitutionGroup?: string;
+  readonly complexType?: ComplexTypeLike;
+  readonly simpleType?: SimpleTypeLike;
+  readonly annotation?: AnnotationLike;
+  readonly key?: readonly unknown[];
+  readonly keyref?: readonly unknown[];
+  readonly unique?: readonly unknown[];
+};
+type ComplexTypeLike = {
+  readonly name?: string;
+  readonly id?: string;
+  readonly abstract?: boolean;
+  readonly mixed?: boolean;
+  readonly sequence?: GroupLike;
+  readonly choice?: GroupLike;
+  readonly all?: GroupLike;
+  readonly group?: GroupRefLike;
+  readonly attribute?: readonly AttributeLike[];
+  readonly attributeGroup?: readonly unknown[];
+  readonly anyAttribute?: AnyAttributeLike;
+  readonly complexContent?: {
+    readonly extension?: ExtensionLike;
+    readonly restriction?: ExtensionLike;
+  };
+  readonly simpleContent?: {
+    readonly extension?: SimpleExtensionLike;
+    readonly restriction?: unknown;
+  };
+  readonly annotation?: AnnotationLike;
+};
+type GroupLike = {
+  readonly minOccurs?: number | string;
+  readonly maxOccurs?: number | string | 'unbounded';
+  readonly element?: readonly ElementLike[];
+  readonly choice?: readonly GroupLike[];
+  readonly sequence?: readonly GroupLike[];
+  readonly group?: readonly GroupRefLike[];
+  readonly any?: readonly unknown[];
+  readonly annotation?: AnnotationLike;
+};
+type GroupRefLike = {
+  readonly ref?: string;
+  readonly minOccurs?: number | string;
+  readonly maxOccurs?: number | string | 'unbounded';
+};
+type AttributeLike = {
+  readonly name?: string;
+  readonly ref?: string;
+  readonly type?: string;
+  readonly use?: 'prohibited' | 'optional' | 'required';
+  readonly default?: string;
+  readonly fixed?: string;
+  readonly id?: string;
+  readonly simpleType?: SimpleTypeLike;
+  readonly annotation?: AnnotationLike;
+};
+type AnyAttributeLike = {
+  readonly namespace?: string;
+  readonly processContents?: 'strict' | 'lax' | 'skip';
+};
+type ExtensionLike = {
+  readonly base?: string;
+  readonly sequence?: GroupLike;
+  readonly choice?: GroupLike;
+  readonly all?: GroupLike;
+  readonly group?: GroupRefLike;
+  readonly attribute?: readonly AttributeLike[];
+  readonly attributeGroup?: readonly unknown[];
+  readonly anyAttribute?: AnyAttributeLike;
+  readonly annotation?: AnnotationLike;
+};
+type SimpleExtensionLike = {
+  readonly base?: string;
+  readonly attribute?: readonly AttributeLike[];
+  readonly attributeGroup?: readonly unknown[];
+  readonly anyAttribute?: AnyAttributeLike;
+};
+type SimpleTypeLike = {
+  readonly name?: string;
+  readonly id?: string;
+  readonly annotation?: AnnotationLike;
+  readonly restriction?: {
+    readonly base?: string;
+    readonly enumeration?: readonly {
+      value: string;
+    }[];
+    readonly pattern?: readonly unknown[];
+    readonly minLength?: readonly unknown[];
+    readonly maxLength?: readonly unknown[];
+    readonly minInclusive?: readonly unknown[];
+    readonly maxInclusive?: readonly unknown[];
+    readonly minExclusive?: readonly unknown[];
+    readonly maxExclusive?: readonly unknown[];
+    readonly whiteSpace?: readonly unknown[];
+    readonly simpleType?: SimpleTypeLike;
+  };
+  readonly list?: {
+    readonly itemType?: string;
+    readonly simpleType?: SimpleTypeLike;
+  };
+  readonly union?: {
+    readonly memberTypes?: string;
+    readonly simpleType?: readonly SimpleTypeLike[];
+  };
+};
+/**
+ * xs:redefine - Redefine types from an included schema (XSD 1.0)
+ * Types defined here override the original definitions from schemaLocation.
+ */
+type RedefineLike = {
+  readonly id?: string;
+  readonly schemaLocation?: string;
+  readonly annotation?: readonly AnnotationLike[];
+  readonly simpleType?: readonly SimpleTypeLike[];
+  readonly complexType?: readonly ComplexTypeLike[];
+  readonly group?: readonly unknown[];
+  readonly attributeGroup?: readonly unknown[];
+};
+/**
+ * xs:override - Override types from an included schema (XSD 1.1)
+ * More powerful than redefine - can override elements, attributes, notations.
+ */
+type OverrideLike = {
+  readonly id?: string;
+  readonly schemaLocation?: string;
+  readonly annotation?: readonly AnnotationLike[];
+  readonly simpleType?: readonly SimpleTypeLike[];
+  readonly complexType?: readonly ComplexTypeLike[];
+  readonly group?: readonly unknown[];
+  readonly attributeGroup?: readonly unknown[];
+  readonly element?: readonly ElementLike[];
+  readonly attribute?: readonly AttributeLike[];
+  readonly notation?: readonly unknown[];
+};
+//#endregion
+//#region src/xsd/parse.d.ts
+/**
+ * Parse an XSD string to a typed Schema object
+ */
+declare function parseXsd(xml: string): Schema;
+//#endregion
+//#region src/xsd/build.d.ts
+interface BuildOptions {
+  /** XML namespace prefix for XSD elements (default: 'xs') */
+  prefix?: string;
+  /** Pretty print with indentation (default: true) */
+  pretty?: boolean;
+  /** Indentation string (default: '  ') */
+  indent?: string;
+}
+/**
+ * Build an XSD string from a typed Schema object
+ */
+declare function buildXsd(schema: Schema, options?: BuildOptions): string;
+//#endregion
+//#region src/xsd/helpers.d.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]
+ * ```
+ */
+declare function resolveImports<T extends Schema>(schema: T, availableSchemas: readonly Schema[]): T & {
+  $imports: readonly Schema[];
+};
+/**
+ * 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
+ * ```
+ */
+declare function linkSchemas<T extends Schema>(schemas: readonly T[]): (T & {
+  $imports: readonly Schema[];
+})[];
+//#endregion
+//#region src/xsd/loader.d.ts
+/** Function to load XSD content from a schemaLocation path */
+type XsdLoader = (schemaLocation: string, basePath: string) => string | null;
+/** Options for schema loading */
+interface LoaderOptions {
+  /** Base directory for resolving relative paths */
+  basePath?: string;
+  /** Custom loader function (default: reads from filesystem) */
+  loader?: XsdLoader;
+  /**
+   * Automatically link schemaLocation references (default: false)
+   * Populates $imports/$includes with actual Schema objects.
+   * The schema structure is preserved - use this when you need cross-schema type resolution.
+   */
+  autoLink?: boolean;
+  /**
+   * Fully resolve the schema after linking (default: false)
+   * Flattens all imports/includes into a single self-contained schema.
+   * Use this when you need a single schema with all types merged.
+   * Implies autoLink: true.
+   */
+  autoResolve?: boolean;
+  /** Throw error if referenced schema cannot be loaded (default: false) */
+  throwOnMissing?: boolean;
+}
+/**
+ * Default XSD loader - reads from filesystem
+ */
+declare function defaultLoader(schemaLocation: string, basePath: string): string | null;
+/**
+ * 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
+ * ```
+ */
+declare function loadSchema(schemaPath: string, options?: LoaderOptions): Schema;
+/**
+ * Load and parse XSD content from a string.
+ */
+declare function parseSchemaContent(content: string, filename?: string): Schema;
+/**
+ * Create a schema loader function that can be passed to the resolver.
+ * The resolver will call this to load schemas referenced by schemaLocation.
+ */
+declare function createSchemaLoader(basePath: string, loader?: XsdLoader): (schemaLocation: string) => Schema | null;
+/** Options for schema linking */
+interface LinkOptions {
+  /** Base directory for resolving relative schemaLocation paths */
+  basePath: string;
+  /** Custom loader function (default: reads from filesystem) */
+  loader?: XsdLoader;
+  /** Whether to throw on missing schemas (default: false - skip missing) */
+  throwOnMissing?: boolean;
+}
+/**
+ * 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
+ * ```
+ */
+declare function linkSchema(schema: Schema, options: LinkOptions): 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
+ * ```
+ */
+declare function loadAndLinkSchema(schemaPath: string, options?: Omit<LoaderOptions, 'basePath'>): Schema;
+//#endregion
+//#region src/xsd/traverser.d.ts
+/** Source of a node in the schema hierarchy */
+type NodeSource = 'direct' | 'redefine' | 'override' | 'include' | 'import';
+/** Traversal options */
+interface TraverseOptions {
+  /** Include $imports in traversal (default: true) */
+  readonly includeImports?: boolean;
+  /** Include $includes in traversal (default: true) */
+  readonly includeIncludes?: boolean;
+  /** Maximum depth to traverse (default: unlimited) */
+  readonly maxDepth?: number;
+}
+/**
+ * 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.
+ */
+declare abstract class SchemaTraverser {
+  /** Root schema being traversed */
+  protected rootSchema: Schema;
+  /** Current schema being visited */
+  protected currentSchema: Schema;
+  /** Source of current node (direct, redefine, override, include, import) */
+  protected source: NodeSource;
+  /** Depth in schema hierarchy (0 = root) */
+  protected depth: number;
+  /** Traversal options */
+  protected options: Required<TraverseOptions>;
+  /** Visited schemas (prevents infinite loops) */
+  private readonly visited;
+  /**
+   * Traverse a schema and all its imports/includes.
+   * Override `on*` methods to handle specific node types.
+   */
+  traverse(schema: Schema, options?: TraverseOptions): this;
+  /** Called when entering a schema */
+  protected onEnterSchema(_schema: Schema): void;
+  /** Called when leaving a schema */
+  protected onLeaveSchema(_schema: Schema): void;
+  /** Called for each top-level complexType */
+  protected onComplexType(_ct: TopLevelComplexType): void;
+  /** Called for each top-level simpleType */
+  protected onSimpleType(_st: TopLevelSimpleType): void;
+  /** Called for each top-level element */
+  protected onElement(_element: TopLevelElement): void;
+  /** Called for each top-level attribute */
+  protected onAttribute(_attr: TopLevelAttribute): void;
+  /** Called for each named group */
+  protected onGroup(_group: NamedGroup): void;
+  /** Called for each named attributeGroup */
+  protected onAttributeGroup(_group: NamedAttributeGroup): void;
+  /** Called for each redefine block */
+  protected onRedefine(_redefine: Redefine): void;
+  /** Called for each override block */
+  protected onOverride(_override: Override): void;
+  private traverseSchema;
+  private traverseSchemaChildren;
+  private traverseRedefines;
+  private traverseOverrides;
+  private traverseIncludes;
+  private traverseImports;
+}
+/** Result of schema resolution */
+interface ResolvedSchema {
+  readonly complexTypes: Map<string, {
+    ct: TopLevelComplexType;
+    schema: Schema;
+  }>;
+  readonly simpleTypes: Map<string, {
+    st: TopLevelSimpleType;
+    schema: Schema;
+  }>;
+  readonly elements: Map<string, {
+    element: TopLevelElement;
+    schema: Schema;
+  }>;
+  readonly attributes: Map<string, {
+    attr: TopLevelAttribute;
+    schema: Schema;
+  }>;
+  readonly groups: Map<string, {
+    group: NamedGroup;
+    schema: Schema;
+  }>;
+  readonly attributeGroups: Map<string, {
+    group: NamedAttributeGroup;
+    schema: Schema;
+  }>;
+  readonly xmlns: Map<string, string>;
+  readonly substitutionGroups: Map<string, TopLevelElement[]>;
+}
+/**
+ * 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
+ */
+declare class SchemaResolver extends SchemaTraverser {
+  readonly complexTypes: Map<string, {
+    ct: TopLevelComplexType;
+    schema: Schema;
+  }>;
+  readonly simpleTypes: Map<string, {
+    st: TopLevelSimpleType;
+    schema: Schema;
+  }>;
+  readonly elements: Map<string, {
+    element: TopLevelElement;
+    schema: Schema;
+  }>;
+  readonly attributes: Map<string, {
+    attr: TopLevelAttribute;
+    schema: Schema;
+  }>;
+  readonly groups: Map<string, {
+    group: NamedGroup;
+    schema: Schema;
+  }>;
+  readonly attributeGroups: Map<string, {
+    group: NamedAttributeGroup;
+    schema: Schema;
+  }>;
+  readonly xmlns: Map<string, string>;
+  readonly substitutionGroups: Map<string, TopLevelElement[]>;
+  /** Get the resolved schema structure */
+  getResolved(): ResolvedSchema;
+  protected onEnterSchema(schema: Schema): void;
+  protected onComplexType(ct: TopLevelComplexType): void;
+  protected onSimpleType(st: TopLevelSimpleType): void;
+  protected onElement(element: TopLevelElement): void;
+  protected onAttribute(attr: TopLevelAttribute): void;
+  protected onGroup(group: NamedGroup): void;
+  protected onAttributeGroup(group: NamedAttributeGroup): void;
+}
+/**
+ * Resolve a schema hierarchy into a flat structure.
+ * Convenience function that creates a SchemaResolver and returns the result.
+ */
+declare function resolveSchemaTypes(schema: Schema, options?: TraverseOptions): ResolvedSchema;
+//#endregion
+//#region src/infer/infer.d.ts
+/**
+ * Infer TypeScript type from a W3C Schema.
+ *
+ * For schemas with multiple root elements, returns a union of all possible
+ * document types. Use type guards or discriminated unions to narrow.
+ *
+ * @example
+ * ```typescript
+ * const schema = {
+ *   element: [
+ *     { name: 'Person', type: 'PersonType' },
+ *     { name: 'Company', type: 'CompanyType' }
+ *   ],
+ *   complexType: [...]
+ * } as const;
+ *
+ * type Data = InferSchema<typeof schema>;
+ * // PersonType | CompanyType (union of all root element types)
+ * ```
+ */
+type InferSchema<T extends SchemaLike> = T['element'] extends readonly ElementLike[] ? InferRootElementTypes<T['element'], T> : unknown;
+/**
+ * Infer union of all root element types (content only, not wrapped).
+ * Each root element's type is inferred and combined into a union.
+ * Use InferParsedSchema for parse() return type which wraps with element name.
+ */
+type InferRootElementTypes<E extends readonly ElementLike[], T extends SchemaLike> = E[number] extends infer El ? El extends ElementLike ? El extends {
+  type: infer TypeName;
+} ? TypeName extends string ? InferTypeName<TypeName, T> : El extends {
+  name: infer N;
+} ? N extends string ? InferTypeName<N, T> : unknown : unknown : El extends {
+  name: infer N;
+} ? N extends string ? InferTypeName<N, T> : unknown : unknown : unknown : unknown;
+/**
+ * Infer wrapped type for parse() function output.
+ * Returns { ElementName: ContentType } to match parse() runtime behavior.
+ *
+ * @example
+ * ```typescript
+ * const result = parse(schema, xml);
+ * // result is { Person: { firstName: string, ... } }
+ * ```
+ */
+type InferParsedSchema<T extends SchemaLike> = T['element'] extends readonly ElementLike[] ? InferWrappedRootElementTypes<T['element'], T> : unknown;
+/**
+ * Infer wrapped root element types for parse() output.
+ * Each root element's type is wrapped with its name: { ElementName: ContentType }
+ */
+type InferWrappedRootElementTypes<E extends readonly ElementLike[], T extends SchemaLike> = E[number] extends infer El ? El extends ElementLike ? El extends {
+  name: infer N;
+} ? N extends string ? El extends {
+  type: infer TypeName;
+} ? TypeName extends string ? { [K in N]: InferTypeName<TypeName, T> } : { [K in N]: InferTypeName<N, T> } : { [K in N]: InferTypeName<N, T> } : unknown : unknown : unknown : unknown;
+/**
+ * Infer TypeScript type for a specific element by name.
+ *
+ * @example
+ * ```typescript
+ * type Person = InferElement<typeof schema, 'Person'>;
+ * ```
+ */
+type InferElement<T extends SchemaLike, ElementName extends string> = FindByName<T['element'], ElementName> extends infer Found ? Found extends {
+  type: infer TypeName;
+} ? TypeName extends string ? InferTypeName<TypeName, T> : InferTypeName<ElementName, T> : Found extends {
+  name: ElementName;
+} ? InferTypeName<ElementName, T> : never : never;
+/**
+ * Infer all elements as a union type.
+ *
+ * @example
+ * ```typescript
+ * type AnyElement = InferAllElements<typeof schema>;
+ * // Person | Address | ...
+ * ```
+ */
+type InferAllElements<T extends SchemaLike> = T['element'] extends readonly {
+  name: string;
+  type?: string;
+}[] ? T['element'][number] extends {
+  type?: infer TypeName;
+} ? TypeName extends string ? InferTypeName<TypeName, T> : never : never : never;
+/** Strip any namespace prefix from a type name (e.g., "tns:PersonType" -> "PersonType") */
+type StripNsPrefix<T extends string> = T extends `${string}:${infer LocalName}` ? LocalName : T;
+/** Resolve a type name to its TypeScript type */
+type InferTypeName<TypeName extends string, T extends SchemaLike> = TypeName extends `xs:${infer BuiltIn}` | `xsd:${infer BuiltIn}` ? InferBuiltInType<BuiltIn> : TypeName extends keyof XsdBuiltInTypes ? XsdBuiltInTypes[TypeName] : FindComplexTypeWithSchema<StripNsPrefix<TypeName>, T> extends infer Result ? Result extends {
+  type: infer CT;
+  schema: infer S;
+} ? CT extends ComplexTypeLike ? S extends SchemaLike ? InferComplexType<CT, S> : unknown : unknown : FindSimpleTypeWithSchema<StripNsPrefix<TypeName>, T> extends infer STResult ? STResult extends {
+  type: infer ST;
+  schema: infer _S;
+} ? ST extends SimpleTypeLike ? InferSimpleType<ST> : unknown : unknown : unknown : unknown;
+/** Find a complexType by name (searches in schema and $imports) */
+type FindComplexType<Name extends string, T extends SchemaLike> = FindComplexTypeLocal<Name, T> extends infer Local ? [Local] extends [never] ? FindComplexTypeInImports<Name, T> : Local : never;
+/** Find complexType WITH the schema it was found in (for proper context in inheritance) */
+type FindComplexTypeWithSchema<Name extends string, T extends SchemaLike> = FindComplexTypeLocal<Name, T> extends infer Local ? [Local] extends [never] ? FindComplexTypeInImportsWithSchema<Name, T> : {
+  type: Local;
+  schema: T;
+} : never;
+/** Find complexType in $imports, returning both type and schema */
+type FindComplexTypeInImportsWithSchema<Name extends string, T extends SchemaLike> = T['$imports'] extends readonly SchemaLike[] ? FindComplexTypeInSchemaArrayWithSchema<Name, T['$imports']> : never;
+/** Search through array of schemas for complexType, returning both type and schema */
+type FindComplexTypeInSchemaArrayWithSchema<Name extends string, Schemas extends readonly SchemaLike[]> = Schemas extends readonly [infer First, ...infer Rest] ? First extends SchemaLike ? FindComplexTypeWithSchema<Name, First> extends infer Found ? [Found] extends [never] ? Rest extends readonly SchemaLike[] ? FindComplexTypeInSchemaArrayWithSchema<Name, Rest> : never : Found extends {
+  type: ComplexTypeLike;
+  schema: SchemaLike;
+} ? Found : Rest extends readonly SchemaLike[] ? FindComplexTypeInSchemaArrayWithSchema<Name, Rest> : never : never : never : never;
+/** Find complexType in current schema only */
+type FindComplexTypeLocal<Name extends string, T extends SchemaLike> = T['complexType'] extends readonly ComplexTypeLike[] ? FindInArray<T['complexType'], {
+  name: Name;
+}> : T['complexType'] extends {
+  readonly [key: string]: ComplexTypeLike;
+} ? Name extends keyof T['complexType'] ? T['complexType'][Name] : never : never;
+/** Find complexType in $imports (recursive) */
+type FindComplexTypeInImports<Name extends string, T extends SchemaLike> = T['$imports'] extends readonly SchemaLike[] ? FindComplexTypeInSchemaArray<Name, T['$imports']> : never;
+/** Search through array of schemas for complexType */
+type FindComplexTypeInSchemaArray<Name extends string, Schemas extends readonly SchemaLike[]> = Schemas extends readonly [infer First, ...infer Rest] ? First extends SchemaLike ? FindComplexType<Name, First> extends infer Found ? [Found] extends [never] ? Rest extends readonly SchemaLike[] ? FindComplexTypeInSchemaArray<Name, Rest> : never : Found : never : never : never;
+/** Find a simpleType by name (searches in schema and $imports) */
+type FindSimpleType<Name extends string, T extends SchemaLike> = FindSimpleTypeLocal<Name, T> extends infer Local ? [Local] extends [never] ? FindSimpleTypeInImports<Name, T> : Local : never;
+/** Find simpleType in current schema only */
+type FindSimpleTypeLocal<Name extends string, T extends SchemaLike> = T['simpleType'] extends readonly SimpleTypeLike[] ? FindInArray<T['simpleType'], {
+  name: Name;
+}> : T['simpleType'] extends {
+  readonly [key: string]: SimpleTypeLike;
+} ? Name extends keyof T['simpleType'] ? T['simpleType'][Name] : never : never;
+/** Find simpleType in $imports (recursive) */
+type FindSimpleTypeInImports<Name extends string, T extends SchemaLike> = T['$imports'] extends readonly SchemaLike[] ? FindSimpleTypeInSchemaArray<Name, T['$imports']> : never;
+/** Search through array of schemas for simpleType */
+type FindSimpleTypeInSchemaArray<Name extends string, Schemas extends readonly SchemaLike[]> = Schemas extends readonly [infer First, ...infer Rest] ? First extends SchemaLike ? FindSimpleType<Name, First> extends infer Found ? [Found] extends [never] ? Rest extends readonly SchemaLike[] ? FindSimpleTypeInSchemaArray<Name, Rest> : never : Found : never : never : never;
+/** Find simpleType WITH the schema it was found in */
+type FindSimpleTypeWithSchema<Name extends string, T extends SchemaLike> = FindSimpleTypeLocal<Name, T> extends infer Local ? [Local] extends [never] ? FindSimpleTypeInImportsWithSchema<Name, T> : {
+  type: Local;
+  schema: T;
+} : never;
+/** Find simpleType in $imports, returning both type and schema */
+type FindSimpleTypeInImportsWithSchema<Name extends string, T extends SchemaLike> = T['$imports'] extends readonly SchemaLike[] ? FindSimpleTypeInSchemaArrayWithSchema<Name, T['$imports']> : never;
+/** Search through array of schemas for simpleType, returning both type and schema */
+type FindSimpleTypeInSchemaArrayWithSchema<Name extends string, Schemas extends readonly SchemaLike[]> = Schemas extends readonly [infer First, ...infer Rest] ? First extends SchemaLike ? FindSimpleTypeWithSchema<Name, First> extends infer Found ? [Found] extends [never] ? Rest extends readonly SchemaLike[] ? FindSimpleTypeInSchemaArrayWithSchema<Name, Rest> : never : Found extends {
+  type: SimpleTypeLike;
+  schema: SchemaLike;
+} ? Found : Rest extends readonly SchemaLike[] ? FindSimpleTypeInSchemaArrayWithSchema<Name, Rest> : never : never : never : never;
+/** Infer type from a complexType definition */
+type InferComplexType<CT extends ComplexTypeLike, T extends SchemaLike> = CT['complexContent'] extends {
+  extension: infer Ext;
+} ? Ext extends ExtensionLike ? InferExtension<Ext, T> & InferComplexTypeContent<CT, T> : InferComplexTypeContent<CT, T> : CT['simpleContent'] extends {
+  extension: infer Ext;
+} ? Ext extends SimpleExtensionLike ? InferSimpleContentExtension<Ext, T> : InferComplexTypeContent<CT, T> : InferComplexTypeContent<CT, T>;
+/** Infer content from complexType (sequence, choice, all, attributes) */
+type InferComplexTypeContent<CT extends ComplexTypeLike, T extends SchemaLike> = InferGroup<CT['sequence'], T> & InferGroup<CT['all'], T> & InferChoice<CT['choice'], T> & InferAttributes<CT['attribute']>;
+/** Empty object type for conditional fallbacks - use {} not Record<string, never> to avoid intersection issues */
+type EmptyObject = {};
+/** Infer from complexContent/extension */
+type InferExtension<Ext extends ExtensionLike, T extends SchemaLike> = (Ext['base'] extends string ? InferTypeName<Ext['base'], T> : EmptyObject) & InferGroup<Ext['sequence'], T> & InferGroup<Ext['all'], T> & InferChoice<Ext['choice'], T> & InferAttributes<Ext['attribute']>;
+/** Infer from simpleContent/extension (text content + attributes) */
+type InferSimpleContentExtension<Ext extends SimpleExtensionLike, _T extends SchemaLike> = (Ext['base'] extends string ? {
+  $value: InferBuiltInType<StripPrefix<Ext['base']>>;
+} : EmptyObject) & InferAttributes<Ext['attribute']>;
+/** Infer from a group (sequence or all) */
+type InferGroup<G, T extends SchemaLike> = G extends GroupLike ? InferElements<G['element'], T> & InferNestedSequences<G['sequence'], T> & InferNestedChoices<G['choice'], T> : EmptyObject;
+/** Infer from choice (union of possibilities) */
+type InferChoice<G, T extends SchemaLike> = G extends GroupLike ? Partial<InferElements<G['element'], T>> : EmptyObject;
+/** Infer nested sequences */
+type InferNestedSequences<S, T extends SchemaLike> = S extends readonly GroupLike[] ? UnionToIntersection<InferGroup<S[number], T>> : EmptyObject;
+/** Infer nested choices */
+type InferNestedChoices<C, T extends SchemaLike> = C extends readonly GroupLike[] ? Partial<UnionToIntersection<InferGroup<C[number], T>>> : EmptyObject;
+/** Infer from element array */
+type InferElements<E, T extends SchemaLike> = E extends readonly ElementLike[] ? InferRequiredElements<E, T> & InferOptionalElements<E, T> : EmptyObject;
+/** Find element by name or ref (after stripping prefix) */
+type FindElementByName<E extends readonly ElementLike[], K extends string> = Extract<E[number], {
+  name: K;
+}> extends never ? E[number] extends infer El ? El extends {
+  ref: infer R;
+} ? R extends string ? StripPrefix<R> extends K ? El : never : never : never : never : Extract<E[number], {
+  name: K;
+}>;
+/** Infer required elements (minOccurs != 0) */
+type InferRequiredElements<E extends readonly ElementLike[], T extends SchemaLike> = { [K in ExtractRequiredElementNames<E>]: InferElementType<FindElementByName<E, K>, T> };
+/** Infer optional elements (minOccurs = 0) */
+type InferOptionalElements<E extends readonly ElementLike[], T extends SchemaLike> = { [K in ExtractOptionalElementNames<E>]?: InferElementType<FindElementByName<E, K>, T> };
+/** Get element name - handles both name and ref (strips prefix from ref) */
+type GetElementName<El> = El extends {
+  name: infer N;
+} ? N extends string ? N : never : El extends {
+  ref: infer R;
+} ? R extends string ? StripPrefix<R> : never : never;
+/** Check if element is optional (minOccurs is 0 or '0') */
+type ElementIsOptional<El> = El extends {
+  minOccurs: infer M;
+} ? M extends 0 | '0' ? true : false : false;
+/** Extract names of required elements (distributive over union) */
+type ExtractRequiredElementNames<E extends readonly ElementLike[]> = { [K in keyof E]: E[K] extends ElementLike ? ElementIsOptional<E[K]> extends true ? never : GetElementName<E[K]> : never }[number];
+/** Extract names of optional elements (distributive over union) */
+type ExtractOptionalElementNames<E extends readonly ElementLike[]> = { [K in keyof E]: E[K] extends ElementLike ? ElementIsOptional<E[K]> extends true ? GetElementName<E[K]> : never : never }[number];
+/** Infer type for a single element */
+type InferElementType<El extends ElementLike, T extends SchemaLike> = El extends {
+  ref: infer Ref;
+} ? Ref extends string ? WrapArray<InferElementRef<Ref, T>, El> : WrapArray<unknown, El> : El extends {
+  complexType: infer CT;
+} ? CT extends ComplexTypeLike ? WrapArray<InferComplexType<CT, T>, El> : WrapArray<unknown, El> : El extends {
+  simpleType: infer ST;
+} ? ST extends SimpleTypeLike ? WrapArray<InferSimpleType<ST>, El> : WrapArray<unknown, El> : El extends {
+  type: infer TypeName;
+} ? TypeName extends string ? WrapArray<InferTypeName<TypeName, T>, El> : WrapArray<unknown, El> : WrapArray<unknown, El>;
+/** Infer type for an element reference - looks up the element in schema or $imports */
+type InferElementRef<Ref extends string, T extends SchemaLike> = FindByName<T['element'], StripPrefix<Ref>> extends infer Found ? [Found] extends [never] ? InferElementFromImports<Ref, T> : Found extends ElementLike ? InferFoundElement<Found, T> : unknown : unknown;
+/** Infer type from a found element */
+type InferFoundElement<Found extends ElementLike, T extends SchemaLike> = Found extends {
+  type: infer TypeName;
+} ? TypeName extends string ? InferTypeName<TypeName, T> : unknown : Found extends {
+  complexType: infer CT;
+} ? CT extends ComplexTypeLike ? InferComplexType<CT, T> : unknown : unknown;
+/** Try to find and infer element from $imports */
+type InferElementFromImports<Ref extends string, T extends SchemaLike> = FindElementInImports<Ref, T['$imports']> extends infer ImportedEl ? [ImportedEl] extends [never] ? unknown : ImportedEl extends ElementLike ? InferFoundElement<ImportedEl, T> : unknown : unknown;
+/** Find element in $imports array */
+type FindElementInImports<Ref extends string, Imports> = Imports extends readonly SchemaLike[] ? Imports[number] extends infer S ? S extends SchemaLike ? FindByName<S['element'], StripPrefix<Ref>> : never : never : never;
+/** Wrap in array if maxOccurs > 1 or unbounded */
+type WrapArray<T, El extends ElementLike> = El extends {
+  maxOccurs: 'unbounded' | infer Max;
+} ? Max extends 'unbounded' ? T[] : Max extends number ? Max extends 0 | 1 ? T : T[] : Max extends '0' | '1' ? T : Max extends `${number}` ? T[] : T : T;
+/** Infer from attribute array */
+type InferAttributes<A> = A extends readonly AttributeLike[] ? InferRequiredAttributes<A> & InferOptionalAttributes<A> : EmptyObject;
+/** Infer required attributes (use="required") */
+type InferRequiredAttributes<A extends readonly AttributeLike[]> = { [K in ExtractRequiredAttributeNames<A>]: InferAttributeType<Extract<A[number], {
+  name: K;
+}>> };
+/** Infer optional attributes (use != "required") */
+type InferOptionalAttributes<A extends readonly AttributeLike[]> = { [K in ExtractOptionalAttributeNames<A>]?: InferAttributeType<Extract<A[number], {
+  name: K;
+}>> };
+/** Extract names of required attributes */
+type ExtractRequiredAttributeNames<A extends readonly AttributeLike[]> = A[number] extends infer Attr ? Attr extends {
+  name: infer N;
+  use: 'required';
+} ? N extends string ? N : never : never : never;
+/** Extract names of optional attributes */
+type ExtractOptionalAttributeNames<A extends readonly AttributeLike[]> = A[number] extends infer Attr ? Attr extends {
+  name: infer N;
+  use?: infer Use;
+} ? Use extends 'required' ? never : N extends string ? N : never : never : never;
+/** Infer type for a single attribute */
+type InferAttributeType<Attr extends AttributeLike> = Attr extends {
+  type: infer TypeName;
+} ? TypeName extends string ? InferBuiltInType<StripPrefix<TypeName>> : string : string;
+/** Infer from simpleType (enums, restrictions) */
+type InferSimpleType<ST extends SimpleTypeLike> = ST extends {
+  restriction: {
+    enumeration: readonly {
+      value: infer V;
+    }[];
+  };
+} ? V extends string ? V : string : ST extends {
+  restriction: {
+    base: infer Base;
+  };
+} ? Base extends string ? InferBuiltInType<StripPrefix<Base>> : string : string;
+/** Map XSD built-in types to TypeScript */
+type XsdBuiltInTypes = {
+  string: string;
+  normalizedString: string;
+  token: string;
+  language: string;
+  Name: string;
+  NCName: string;
+  ID: string;
+  IDREF: string;
+  IDREFS: string[];
+  ENTITY: string;
+  ENTITIES: string[];
+  NMTOKEN: string;
+  NMTOKENS: string[];
+  boolean: boolean;
+  base64Binary: string;
+  hexBinary: string;
+  float: number;
+  double: number;
+  decimal: number;
+  integer: number;
+  nonPositiveInteger: number;
+  negativeInteger: number;
+  long: number;
+  int: number;
+  short: number;
+  byte: number;
+  nonNegativeInteger: number;
+  unsignedLong: number;
+  unsignedInt: number;
+  unsignedShort: number;
+  unsignedByte: number;
+  positiveInteger: number;
+  date: string;
+  time: string;
+  dateTime: string;
+  duration: string;
+  gYear: string;
+  gYearMonth: string;
+  gMonth: string;
+  gMonthDay: string;
+  gDay: string;
+  anyURI: string;
+  QName: string;
+  NOTATION: string;
+  anyType: unknown;
+  anySimpleType: string | number | boolean;
+};
+/** Infer built-in type by name */
+type InferBuiltInType<Name extends string> = Name extends keyof XsdBuiltInTypes ? XsdBuiltInTypes[Name] : unknown;
+/** Strip any namespace prefix (e.g., xs:string -> string, atom:link -> link) */
+type StripPrefix<T extends string> = T extends `${string}:${infer Rest}` ? Rest : T;
+/** Find item in array by partial match */
+type FindInArray<Arr, Match> = Arr extends readonly [infer First, ...infer Rest] ? First extends Match ? First : FindInArray<Rest, Match> : Arr extends readonly (infer Item)[] ? Item extends Match ? Extract<Item, Match> : never : never;
+/**
+ * Find item in array by name property.
+ * Works with both literal types ('abapClass') and widened types (string).
+ * For widened arrays where name is `string`, returns the full item union.
+ */
+type FindByName<Arr, Name extends string> = Arr extends readonly [infer First, ...infer Rest] ? First extends {
+  name: Name;
+} ? First : First extends {
+  name: string;
+} ? Name extends First['name'] ? First : FindByName<Rest, Name> : FindByName<Rest, Name> : Arr extends readonly (infer Item)[] ? Item extends {
+  name: infer ItemName;
+} ? ItemName extends string ? string extends ItemName ? Item : Name extends ItemName ? Item : never : never : never : never;
+/** Convert union to intersection */
+type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+//#endregion
+//#region src/codegen/generate.d.ts
+/**
+ * Schema Literal Generator
+ *
+ * Transforms a parsed Schema object into a TypeScript literal string
+ * that preserves type information for InferSchema<T>.
+ */
+interface GenerateOptions {
+  /** Variable name for the exported schema */
+  name?: string;
+  /** Add JSDoc comment */
+  comment?: string;
+  /** Pretty print with indentation */
+  pretty?: boolean;
+  /** Indentation string (default: '  ') */
+  indent?: string;
+  /**
+   * Enable specific $ metadata features in output.
+   * - `$xmlns`: Keep `$xmlns` in output (already parsed as $xmlns)
+   * - `$imports`: Rename `import` → `$imports` for schema linking
+   * - `$filename`: Include `$filename` (uses `name` option + '.xsd')
+   *
+   * @example
+   * ```typescript
+   * features: { $xmlns: true, $imports: true, $filename: true }
+   * ```
+   */
+  features?: {
+    /** Keep `$xmlns` in output */$xmlns?: boolean; /** Rename `import` → `$imports` for schema linking */
+    $imports?: boolean; /** Include `$filename` (uses `name` + '.xsd') */
+    $filename?: boolean;
+  };
+  /**
+   * Property names to exclude from output.
+   * Useful for removing annotations, documentation, etc.
+   *
+   * @example
+   * ```typescript
+   * exclude: ['annotation']  // Remove all annotation elements
+   * ```
+   */
+  exclude?: string[];
+  /** Resolver for import paths (schemaLocation -> module path) */
+  importResolver?: (schemaLocation: string) => string | null;
+  /**
+   * Generate isolatedDeclarations-compatible output.
+   * Uses `satisfies Schema as const` instead of just `as const`.
+   */
+  isolatedDeclarations?: boolean;
+  /** Use single quotes for string literals and property names */
+  singleQuote?: boolean;
+}
+/**
+ * Generate a TypeScript literal string from XSD content.
+ *
+ * @param xsdContent - XSD file content as string
+ * @param options - Generation options
+ * @returns TypeScript code with schema as const literal
+ *
+ * @example
+ * ```typescript
+ * const xsd = `<xs:schema>...</xs:schema>`;
+ * const code = generateSchemaLiteral(xsd, { name: 'PersonSchema' });
+ * // export const PersonSchema = { ... } as const;
+ * ```
+ */
+declare function generateSchemaLiteral(xsdContent: string, options?: GenerateOptions): string;
+/**
+ * Generate a complete TypeScript file from XSD content.
+ *
+ * @param xsdContent - XSD file content as string
+ * @param options - Generation options
+ * @returns Complete TypeScript file content
+ */
+declare function generateSchemaFile(xsdContent: string, options?: GenerateOptions): string;
+//#endregion
+//#region src/codegen/ts-morph.d.ts
+/**
+ * Resolver function for loading schemas by schemaLocation.
+ * @param schemaLocation - The schemaLocation path from the import element
+ * @param basePath - Optional base path for resolving relative paths
+ * @returns The resolved Schema, or undefined if not found
+ */
+type SchemaLocationResolver = (schemaLocation: string, basePath?: string) => Schema | undefined;
+interface SchemaToSourceFileOptions {
+  /** Custom root type name. Pass null to disable root type generation. */
+  rootTypeName?: string | null;
+  /** Add JSDoc comments */
+  addJsDoc?: boolean;
+  /** Existing project to use */
+  project?: Project;
+  /** Base path for loading schemaLocation imports */
+  basePath?: string;
+  /**
+   * Resolver function for loading schemas by schemaLocation.
+   * If provided, will be called for each `import` element with a schemaLocation.
+   * The resolved schemas will be processed like $imports.
+   */
+  schemaLocationResolver?: SchemaLocationResolver;
+}
+//#endregion
+//#region src/codegen/interface-generator.d.ts
+interface GenerateInterfacesOptions extends SchemaToSourceFileOptions {
+  /**
+   * If true, generates a single flattened type with all nested types inlined.
+   * If false (default), generates interfaces with imports and extends.
+   */
+  flatten?: boolean;
+  /**
+   * Additional source files to include for resolving imports when flattening.
+   * These are typically the generated source files from $imports schemas.
+   */
+  additionalSourceFiles?: SourceFile[];
+}
+interface GenerateInterfacesResult {
+  /** The generated TypeScript code */
+  code: string;
+  /** The ts-morph SourceFile */
+  sourceFile: SourceFile;
+  /** The root type name */
+  rootTypeName: string | undefined;
+  /** The ts-morph Project (useful for further manipulation) */
+  project: Project;
+}
+/**
+ * Derive root type name from schema filename.
+ * e.g., 'packagesV1.xsd' -> 'PackagesV1Schema'
+ */
+declare function deriveRootTypeName(filename?: string): string | undefined;
+/**
+ * Generate TypeScript interfaces from a schema.
+ *
+ * @param schema - The schema to generate interfaces from
+ * @param options - Generation options
+ * @returns Generated TypeScript code and metadata
+ *
+ * @example
+ * // Generate interfaces with imports and extends
+ * const { code } = generateInterfaces(schema);
+ *
+ * @example
+ * // Generate a single flattened type with all nested types inlined
+ * const { code } = generateInterfaces(schema, {
+ *   flatten: true,
+ *   additionalSourceFiles: [baseSchemaSourceFile]
+ * });
+ */
+declare function generateInterfaces(schema: Schema, options?: GenerateInterfacesOptions): GenerateInterfacesResult;
+//#endregion
+//#region src/xml/parse.d.ts
+/**
+ * Parse XML string to typed object using schema definition
+ */
+declare function parse<T extends SchemaLike>(schema: T, xml: string): InferParsedSchema<T>;
+//#endregion
+//#region src/xml/build-utils.d.ts
+interface BuildOptions$1 {
+  /** Include XML declaration (default: true) */
+  xmlDecl?: boolean;
+  /** XML encoding (default: utf-8) */
+  encoding?: string;
+  /** Pretty print with indentation (default: false) */
+  pretty?: boolean;
+  /** Namespace prefix to use (default: from schema or none) */
+  prefix?: string;
+  /** Root element name to use (default: auto-detect from data) */
+  rootElement?: string;
+}
+//#endregion
+//#region src/xml/build.d.ts
+/**
+ * Build XML string from typed object using schema definition
+ */
+declare function build<T extends SchemaLike>(schema: T, data: unknown, options?: BuildOptions$1): string;
+//#endregion
+//#region src/xml/typed.d.ts
+/**
+ * Typed schema instance with parse/build methods
+ */
+interface TypedSchema<T, S extends SchemaLike = SchemaLike> {
+  /** The data type - use with typeof for type extraction */
+  readonly _type: T;
+  /** The underlying raw schema */
+  readonly schema: S;
+  /** Parse XML string to typed object */
+  parse(xml: string): T;
+  /** Build typed object to XML string */
+  build(data: T, options?: BuildOptions$1): string;
+}
+/** Resolve data type: use explicit T if provided, otherwise infer from schema */
+type ResolveDataType<T, S extends SchemaLike> = unknown extends T ? InferSchema<S> : T;
+/** Extract the data type from a TypedSchema */
+type InferTypedSchema<T extends TypedSchema<unknown>> = T['_type'];
+/**
+ * Create a typed schema wrapper
+ *
+ * @param schema - Raw schema literal (with `as const`)
+ * @returns Typed schema with parse/build methods
+ *
+ * @example
+ * ```typescript
+ * // Infer type from schema
+ * const personSchema = typedSchema(rawPersonSchema);
+ * const person = personSchema.parse(xml);
+ *
+ * // Or with explicit type
+ * const personSchema = typedSchema<PersonType>(rawPersonSchema);
+ * ```
+ */
+declare function typedSchema<T = unknown, S extends SchemaLike = SchemaLike>(schema: S): TypedSchema<ResolveDataType<T, S>, S>;
+//#endregion
+//#region src/walker/index.d.ts
+/** Result of walking complexTypes */
+type ComplexTypeEntry = {
+  readonly ct: ComplexTypeLike;
+  readonly schema: SchemaLike;
+};
+/** Result of walking simpleTypes */
+type SimpleTypeEntry = {
+  readonly st: SimpleTypeLike;
+  readonly schema: SchemaLike;
+};
+/** Result of walking elements */
+type ElementEntry = {
+  readonly element: ElementLike; /** Element is optional (minOccurs=0 or inside choice) */
+  readonly optional: boolean; /** Element is array (maxOccurs > 1 or unbounded) */
+  readonly array: boolean; /** Source group type */
+  readonly source: 'sequence' | 'choice' | 'all' | 'extension'; /** Schema where the element is defined (for namespace prefix resolution) */
+  readonly schema: SchemaLike;
+};
+/** Result of walking attributes */
+type AttributeEntry = {
+  readonly attribute: AttributeLike; /** Attribute is required (use="required") */
+  readonly required: boolean; /** Schema where the attribute is defined (for namespace prefix resolution) */
+  readonly schema: SchemaLike;
+};
+/** Result of walking top-level elements */
+type TopLevelElementEntry = {
+  readonly element: ElementLike;
+  readonly schema: SchemaLike;
+};
+/** Options for schema-level walkers */
+type WalkOptions = {
+  /** Only recurse into $includes, not $imports (default: false) */readonly includesOnly?: boolean;
+};
+/**
+ * Walk all complexTypes in a schema and its $imports/$includes (depth-first).
+ *
+ * @param schema - Root schema to start from
+ * @param options - Walk options (e.g., includesOnly to skip $imports)
+ * @yields ComplexType with the schema it was found in
+ *
+ * @example
+ * ```typescript
+ * function findComplexType(name: string, schema: SchemaLike) {
+ *   for (const { ct, schema: s } of walkComplexTypes(schema)) {
+ *     if (ct.name === name) return { type: ct, schema: s };
+ *   }
+ * }
+ * ```
+ */
+declare function walkComplexTypes(schema: SchemaLike, options?: WalkOptions): Generator<ComplexTypeEntry>;
+/**
+ * Walk all simpleTypes in a schema and its $imports/$includes.
+ */
+declare function walkSimpleTypes(schema: SchemaLike, options?: WalkOptions): Generator<SimpleTypeEntry>;
+/**
+ * Walk all top-level elements in a schema and its $imports/$includes.
+ */
+declare function walkTopLevelElements(schema: SchemaLike, options?: WalkOptions): Generator<TopLevelElementEntry>;
+/**
+ * Find a complexType by name, searching schema and $imports.
+ * Returns both the type AND the schema it was found in (important for inheritance).
+ */
+declare function findComplexType(name: string, schema: SchemaLike): ComplexTypeEntry | undefined;
+/**
+ * Find a simpleType by name, searching schema and $imports.
+ */
+declare function findSimpleType(name: string, schema: SchemaLike): SimpleTypeEntry | undefined;
+/**
+ * Find a top-level element by name, searching schema and $imports.
+ */
+declare function findElement(name: string, schema: SchemaLike): TopLevelElementEntry | undefined;
+/**
+ * Walk all elements in a complexType, handling:
+ * - sequence, choice, all groups
+ * - Nested groups (recursive)
+ * - complexContent/extension inheritance
+ * - Group references
+ *
+ * @param ct - ComplexType to walk
+ * @param schema - Schema context (for resolving base types and group refs)
+ * @yields Elements with metadata (optional, array, source)
+ */
+declare function walkElements(ct: ComplexTypeLike, schema: SchemaLike): Generator<ElementEntry>;
+/**
+ * Walk all attributes in a complexType, handling:
+ * - Direct attributes
+ * - complexContent/extension attributes
+ * - simpleContent/extension attributes
+ * - Inherited attributes from base type
+ * - AttributeGroup references
+ */
+declare function walkAttributes(ct: ComplexTypeLike, schema: SchemaLike): Generator<AttributeEntry>;
+/**
+ * Strip namespace prefix from a QName (e.g., "tns:PersonType" -> "PersonType")
+ */
+declare function stripNsPrefix(name: string): string;
+/**
+ * Check if an element is abstract
+ */
+declare function isAbstractElement(element: ElementLike): boolean;
+/**
+ * Find all elements that substitute for a given abstract element.
+ * This handles XSD substitution groups where concrete elements can
+ * substitute for an abstract element.
+ */
+declare function findSubstitutes(abstractElementName: string, schema: SchemaLike): ElementLike[];
+//#endregion
+export { AfterAllContext, All, Alternative, Annotated, Annotation, AnnotationLike, Any, AnyAttribute, AnyAttributeLike, Appinfo, Assertion, Attribute, AttributeEntry, AttributeGroupRef, AttributeLike, type BuildOptions, CodegenConfig, ComplexContent, ComplexContentExtension, ComplexContentRestriction, ComplexType, ComplexTypeEntry, ComplexTypeLike, DefaultOpenContent, Documentation, Element, ElementEntry, ElementLike, ExplicitGroup, ExtensionLike, ExtractOptionalAttributeNames, ExtractOptionalElementNames, ExtractRequiredAttributeNames, ExtractRequiredElementNames, Facet, Field, FinalizeContext, FindByName, FindComplexType, FindComplexTypeInImports, FindComplexTypeInImportsWithSchema, FindComplexTypeInSchemaArray, FindComplexTypeInSchemaArrayWithSchema, FindComplexTypeLocal, FindComplexTypeWithSchema, FindInArray, FindSimpleType, FindSimpleTypeInImports, FindSimpleTypeInImportsWithSchema, FindSimpleTypeInSchemaArray, FindSimpleTypeInSchemaArrayWithSchema, FindSimpleTypeLocal, FindSimpleTypeWithSchema, FormChoice, type GenerateInterfacesOptions, type GenerateInterfacesResult, GeneratedFile, GeneratorPlugin, Group, GroupLike, GroupRef, GroupRefLike, HookContext, Import, Include, InferAllElements, InferAttributeType, InferAttributes, InferBuiltInType, InferChoice, InferComplexType, InferComplexTypeContent, InferElement, InferElementType, InferElements, InferExtension, InferGroup, InferNestedChoices, InferNestedSequences, InferOptionalAttributes, InferOptionalElements, InferParsedSchema, InferRequiredAttributes, InferRequiredElements, InferRootElementTypes, InferSchema, InferSimpleContentExtension, InferSimpleType, InferTypeName, type InferTypedSchema, InferWrappedRootElementTypes, Key, Keyref, LinkOptions, List, LoaderOptions, LocalAttribute, LocalComplexType, LocalElement, LocalSimpleType, NamedAttributeGroup, NamedGroup, NodeSource, Notation, OpenAttrs, OpenContent, Override, OverrideLike, Pattern, Redefine, RedefineLike, ResolveOptions, ResolvedSchema, type RunnerOptions, type RunnerResult, Schema, SchemaAttrs, SchemaExtensions, SchemaInfo, SchemaLike, SchemaResolver, SchemaTraverser, Selector, SetupContext, SimpleContent, SimpleContentExtension, SimpleContentRestriction, SimpleExtensionLike, SimpleType, SimpleTypeEntry, SimpleTypeLike, SimpleTypeRestriction, SourceConfig, SourceInfo, StripNsPrefix, StripPrefix, TopLevelAttribute, TopLevelComplexType, TopLevelElement, TopLevelElementEntry, TopLevelSimpleType, TransformContext, TraverseOptions, type TypedSchema, Union, UnionToIntersection, Unique, WalkOptions, WrapArray, type BuildOptions$1 as XmlBuildOptions, XmlnsDeclarations, XsdBuiltInTypes, XsdLoader, build as buildXml, buildXsd, createSchemaLoader, defaultLoader, defineConfig, deriveRootTypeName, findComplexType, findElement, findSimpleType, findSubstitutes, generateInterfaces, generateSchemaFile, generateSchemaLiteral, getSubstitutes, isAbstractElement, linkSchema, linkSchemas, loadAndLinkSchema, loadSchema, parseXsd as parse, parseXsd, parseSchemaContent, parse as parseXml, resolveImports, resolveSchema, resolveSchemaTypes, runCodegen, stripNsPrefix, typedSchema, walkAttributes, walkComplexTypes, walkElements, walkSimpleTypes, walkTopLevelElements };
+//# sourceMappingURL=index.d.mts.map