@abapify/ts-xsd 0.4.0 → 0.4.3

package/dist/runner-D1RCU_go.d.mts

@@ -0,0 +1,741 @@
+//#region src/xsd/types.d.ts
+/**
+ * XSD Types - TypeScript representation of W3C XML Schema Definition
+ *
+ * Based on: https://www.w3.org/TR/xmlschema11-1/XMLSchema.xsd
+ *
+ * These types represent the structure of XSD documents.
+ * They are designed to be the result of parsing XMLSchema.xsd itself.
+ */
+/**
+ * XML namespace declarations (xmlns:prefix -> URI mappings)
+ *
+ * This is not part of XSD itself, but part of XML Namespaces spec.
+ * XSD documents rely on xmlns declarations to resolve QName prefixes.
+ *
+ * @example
+ * ```typescript
+ * xmlns: {
+ *   xs: "http://www.w3.org/2001/XMLSchema",
+ *   tns: "http://example.com/myschema",
+ *   "": "http://example.com/default"  // default namespace (no prefix)
+ * }
+ * ```
+ */
+type XmlnsDeclarations = {
+  readonly [prefix: string]: string;
+};
+/**
+ * xs:openAttrs - base type extended by almost all schema types
+ * Allows attributes from other namespaces
+ */
+interface OpenAttrs {
+  /**
+   * XML namespace declarations scoped to this element (xmlns:prefix -> namespace URI).
+   * Inherited by child elements unless overridden.
+   *
+   * Note: Prefixed with $ to indicate this is NOT a W3C XSD property -
+   * it's extracted from XML namespace attributes.
+   */
+  readonly $xmlns?: XmlnsDeclarations;
+  /** Any additional attributes from other namespaces */
+  [key: string]: unknown;
+}
+/**
+ * Schema-level extensions (non-W3C properties).
+ * Properties prefixed with $ are clearly non-W3C.
+ */
+interface SchemaAttrs extends OpenAttrs {
+  /**
+   * Namespace prefix declarations (xmlns:prefix -> namespace URI).
+   * Extracted from XML namespace attributes, not part of XSD spec.
+   */
+  readonly $xmlns?: {
+    readonly [prefix: string]: string;
+  };
+  /**
+   * Original filename/path of this schema.
+   * Used to reconstruct $imports relationships from schemaLocation references.
+   */
+  readonly $filename?: string;
+  /**
+   * Resolved imported schemas for cross-schema type resolution (xs:import).
+   * Actual schema objects that can be searched for type definitions.
+   * Use this to link schemas that import each other (different namespace).
+   */
+  readonly $imports?: readonly Schema[];
+  /**
+   * Resolved included schemas for same-namespace type resolution (xs:include).
+   * 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 Schema[];
+}
+/**
+ * xs:annotated - base type for elements that can have annotation
+ */
+interface Annotated extends OpenAttrs {
+  readonly id?: string;
+  readonly annotation?: Annotation;
+}
+interface Annotation extends OpenAttrs {
+  readonly id?: string;
+  readonly appinfo?: Appinfo[];
+  readonly documentation?: Documentation[];
+}
+interface Appinfo extends OpenAttrs {
+  readonly source?: string;
+  readonly _text?: string;
+}
+interface Documentation extends OpenAttrs {
+  readonly source?: string;
+  readonly 'xml:lang'?: string;
+  readonly _text?: string;
+}
+/**
+ * xs:schema - the root element of an XSD document
+ */
+interface Schema extends SchemaAttrs {
+  readonly id?: string;
+  readonly targetNamespace?: string;
+  readonly version?: string;
+  readonly finalDefault?: string;
+  readonly blockDefault?: string;
+  readonly attributeFormDefault?: FormChoice;
+  readonly elementFormDefault?: FormChoice;
+  readonly defaultAttributes?: string;
+  readonly xpathDefaultNamespace?: string;
+  readonly 'xml:lang'?: string;
+  readonly include?: Include[];
+  readonly import?: Import[];
+  readonly redefine?: Redefine[];
+  readonly override?: Override[];
+  readonly annotation?: Annotation[];
+  readonly simpleType?: TopLevelSimpleType[];
+  readonly complexType?: TopLevelComplexType[];
+  readonly group?: NamedGroup[];
+  readonly attributeGroup?: NamedAttributeGroup[];
+  readonly element?: TopLevelElement[];
+  readonly attribute?: TopLevelAttribute[];
+  readonly notation?: Notation[];
+  readonly defaultOpenContent?: DefaultOpenContent;
+}
+type FormChoice = 'qualified' | 'unqualified';
+interface Include extends Annotated {
+  readonly schemaLocation: string;
+}
+interface Import extends Annotated {
+  readonly namespace?: string;
+  readonly schemaLocation?: string;
+}
+interface Redefine extends OpenAttrs {
+  readonly id?: string;
+  readonly schemaLocation: string;
+  readonly annotation?: Annotation[];
+  readonly simpleType?: TopLevelSimpleType[];
+  readonly complexType?: TopLevelComplexType[];
+  readonly group?: NamedGroup[];
+  readonly attributeGroup?: NamedAttributeGroup[];
+}
+interface Override extends OpenAttrs {
+  readonly id?: string;
+  readonly schemaLocation: string;
+  readonly annotation?: Annotation[];
+  readonly simpleType?: TopLevelSimpleType[];
+  readonly complexType?: TopLevelComplexType[];
+  readonly group?: NamedGroup[];
+  readonly attributeGroup?: NamedAttributeGroup[];
+  readonly element?: TopLevelElement[];
+  readonly attribute?: TopLevelAttribute[];
+  readonly notation?: Notation[];
+}
+/**
+ * xs:element (top-level)
+ */
+interface TopLevelElement extends Annotated {
+  readonly name: string;
+  readonly type?: string;
+  readonly substitutionGroup?: string;
+  readonly default?: string;
+  readonly fixed?: string;
+  readonly nillable?: boolean;
+  readonly abstract?: boolean;
+  readonly final?: string;
+  readonly block?: string;
+  readonly simpleType?: LocalSimpleType;
+  readonly complexType?: LocalComplexType;
+  readonly unique?: Unique[];
+  readonly key?: Key[];
+  readonly keyref?: Keyref[];
+  readonly alternative?: Alternative[];
+}
+/**
+ * xs:element (local, within complexType)
+ */
+interface LocalElement extends Annotated {
+  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 nillable?: boolean;
+  readonly block?: string;
+  readonly form?: FormChoice;
+  readonly targetNamespace?: string;
+  readonly simpleType?: LocalSimpleType;
+  readonly complexType?: LocalComplexType;
+  readonly unique?: Unique[];
+  readonly key?: Key[];
+  readonly keyref?: Keyref[];
+  readonly alternative?: Alternative[];
+}
+/**
+ * xs:attribute (top-level)
+ */
+interface TopLevelAttribute extends Annotated {
+  readonly name: string;
+  readonly type?: string;
+  readonly default?: string;
+  readonly fixed?: string;
+  readonly inheritable?: boolean;
+  readonly simpleType?: LocalSimpleType;
+}
+/**
+ * xs:attribute (local, within complexType)
+ */
+interface LocalAttribute extends Annotated {
+  readonly name?: string;
+  readonly ref?: string;
+  readonly type?: string;
+  readonly use?: 'prohibited' | 'optional' | 'required';
+  readonly default?: string;
+  readonly fixed?: string;
+  readonly form?: FormChoice;
+  readonly targetNamespace?: string;
+  readonly inheritable?: boolean;
+  readonly simpleType?: LocalSimpleType;
+}
+/**
+ * xs:complexType (top-level, named)
+ */
+interface TopLevelComplexType extends Annotated {
+  readonly name: string;
+  readonly mixed?: boolean;
+  readonly abstract?: boolean;
+  readonly final?: string;
+  readonly block?: string;
+  readonly defaultAttributesApply?: boolean;
+  readonly simpleContent?: SimpleContent;
+  readonly complexContent?: ComplexContent;
+  readonly openContent?: OpenContent;
+  readonly group?: GroupRef;
+  readonly all?: All;
+  readonly choice?: ExplicitGroup;
+  readonly sequence?: ExplicitGroup;
+  readonly attribute?: LocalAttribute[];
+  readonly attributeGroup?: AttributeGroupRef[];
+  readonly anyAttribute?: AnyAttribute;
+  readonly assert?: Assertion[];
+}
+/**
+ * xs:complexType (local, inline)
+ */
+interface LocalComplexType extends Annotated {
+  readonly mixed?: boolean;
+  readonly simpleContent?: SimpleContent;
+  readonly complexContent?: ComplexContent;
+  readonly openContent?: OpenContent;
+  readonly group?: GroupRef;
+  readonly all?: All;
+  readonly choice?: ExplicitGroup;
+  readonly sequence?: ExplicitGroup;
+  readonly attribute?: LocalAttribute[];
+  readonly attributeGroup?: AttributeGroupRef[];
+  readonly anyAttribute?: AnyAttribute;
+  readonly assert?: Assertion[];
+}
+/**
+ * xs:simpleType (top-level, named)
+ */
+interface TopLevelSimpleType extends Annotated {
+  readonly name: string;
+  readonly final?: string;
+  readonly restriction?: SimpleTypeRestriction;
+  readonly list?: List;
+  readonly union?: Union;
+}
+/**
+ * xs:simpleType (local, inline)
+ */
+interface LocalSimpleType extends Annotated {
+  readonly restriction?: SimpleTypeRestriction;
+  readonly list?: List;
+  readonly union?: Union;
+}
+interface SimpleTypeRestriction extends Annotated {
+  readonly base?: string;
+  readonly simpleType?: LocalSimpleType;
+  readonly minExclusive?: Facet[];
+  readonly minInclusive?: Facet[];
+  readonly maxExclusive?: Facet[];
+  readonly maxInclusive?: Facet[];
+  readonly totalDigits?: Facet[];
+  readonly fractionDigits?: Facet[];
+  readonly length?: Facet[];
+  readonly minLength?: Facet[];
+  readonly maxLength?: Facet[];
+  readonly enumeration?: Facet[];
+  readonly whiteSpace?: Facet[];
+  readonly pattern?: Pattern[];
+  readonly assertion?: Assertion[];
+  readonly explicitTimezone?: Facet[];
+}
+interface List extends Annotated {
+  readonly itemType?: string;
+  readonly simpleType?: LocalSimpleType;
+}
+interface Union extends Annotated {
+  readonly memberTypes?: string;
+  readonly simpleType?: LocalSimpleType[];
+}
+interface Facet extends Annotated {
+  readonly value: string;
+  readonly fixed?: boolean;
+}
+interface Pattern extends Annotated {
+  readonly value: string;
+}
+interface ComplexContent extends Annotated {
+  readonly mixed?: boolean;
+  readonly restriction?: ComplexContentRestriction;
+  readonly extension?: ComplexContentExtension;
+}
+interface SimpleContent extends Annotated {
+  readonly restriction?: SimpleContentRestriction;
+  readonly extension?: SimpleContentExtension;
+}
+interface ComplexContentRestriction extends Annotated {
+  readonly base: string;
+  readonly openContent?: OpenContent;
+  readonly group?: GroupRef;
+  readonly all?: All;
+  readonly choice?: ExplicitGroup;
+  readonly sequence?: ExplicitGroup;
+  readonly attribute?: LocalAttribute[];
+  readonly attributeGroup?: AttributeGroupRef[];
+  readonly anyAttribute?: AnyAttribute;
+  readonly assert?: Assertion[];
+}
+interface ComplexContentExtension extends Annotated {
+  readonly base: string;
+  readonly openContent?: OpenContent;
+  readonly group?: GroupRef;
+  readonly all?: All;
+  readonly choice?: ExplicitGroup;
+  readonly sequence?: ExplicitGroup;
+  readonly attribute?: LocalAttribute[];
+  readonly attributeGroup?: AttributeGroupRef[];
+  readonly anyAttribute?: AnyAttribute;
+  readonly assert?: Assertion[];
+}
+interface SimpleContentRestriction extends Annotated {
+  readonly base: string;
+  readonly simpleType?: LocalSimpleType;
+  readonly minExclusive?: Facet[];
+  readonly minInclusive?: Facet[];
+  readonly maxExclusive?: Facet[];
+  readonly maxInclusive?: Facet[];
+  readonly totalDigits?: Facet[];
+  readonly fractionDigits?: Facet[];
+  readonly length?: Facet[];
+  readonly minLength?: Facet[];
+  readonly maxLength?: Facet[];
+  readonly enumeration?: Facet[];
+  readonly whiteSpace?: Facet[];
+  readonly pattern?: Pattern[];
+  readonly assertion?: Assertion[];
+  readonly explicitTimezone?: Facet[];
+  readonly attribute?: LocalAttribute[];
+  readonly attributeGroup?: AttributeGroupRef[];
+  readonly anyAttribute?: AnyAttribute;
+  readonly assert?: Assertion[];
+}
+interface SimpleContentExtension extends Annotated {
+  readonly base: string;
+  readonly attribute?: LocalAttribute[];
+  readonly attributeGroup?: AttributeGroupRef[];
+  readonly anyAttribute?: AnyAttribute;
+  readonly assert?: Assertion[];
+}
+/**
+ * xs:sequence / xs:choice (explicit group)
+ */
+interface ExplicitGroup extends Annotated {
+  readonly minOccurs?: number | string;
+  readonly maxOccurs?: number | string | 'unbounded';
+  readonly element?: LocalElement[];
+  readonly group?: GroupRef[];
+  readonly choice?: ExplicitGroup[];
+  readonly sequence?: ExplicitGroup[];
+  readonly any?: Any[];
+}
+/**
+ * xs:all
+ */
+interface All extends Annotated {
+  readonly minOccurs?: number | string;
+  readonly maxOccurs?: number | string;
+  readonly element?: LocalElement[];
+  readonly any?: Any[];
+  readonly group?: GroupRef[];
+}
+/**
+ * xs:group (named, top-level)
+ */
+interface NamedGroup extends Annotated {
+  readonly name: string;
+  readonly all?: All;
+  readonly choice?: ExplicitGroup;
+  readonly sequence?: ExplicitGroup;
+}
+/**
+ * xs:group (reference)
+ */
+interface GroupRef extends Annotated {
+  readonly ref: string;
+  readonly minOccurs?: number | string;
+  readonly maxOccurs?: number | string | 'unbounded';
+}
+/**
+ * xs:attributeGroup (named, top-level)
+ */
+interface NamedAttributeGroup extends Annotated {
+  readonly name: string;
+  readonly attribute?: LocalAttribute[];
+  readonly attributeGroup?: AttributeGroupRef[];
+  readonly anyAttribute?: AnyAttribute;
+}
+/**
+ * xs:attributeGroup (reference)
+ */
+interface AttributeGroupRef extends Annotated {
+  readonly ref: string;
+}
+interface Any extends Annotated {
+  readonly minOccurs?: number | string;
+  readonly maxOccurs?: number | string | 'unbounded';
+  readonly namespace?: string;
+  readonly processContents?: 'skip' | 'lax' | 'strict';
+  readonly notNamespace?: string;
+  readonly notQName?: string;
+}
+interface AnyAttribute extends Annotated {
+  readonly namespace?: string;
+  readonly processContents?: 'skip' | 'lax' | 'strict';
+  readonly notNamespace?: string;
+  readonly notQName?: string;
+}
+interface Unique extends Annotated {
+  readonly name: string;
+  readonly ref?: string;
+  readonly selector?: Selector;
+  readonly field?: Field[];
+}
+interface Key extends Annotated {
+  readonly name: string;
+  readonly ref?: string;
+  readonly selector?: Selector;
+  readonly field?: Field[];
+}
+interface Keyref extends Annotated {
+  readonly name: string;
+  readonly ref?: string;
+  readonly refer: string;
+  readonly selector?: Selector;
+  readonly field?: Field[];
+}
+interface Selector extends Annotated {
+  readonly xpath: string;
+  readonly xpathDefaultNamespace?: string;
+}
+interface Field extends Annotated {
+  readonly xpath: string;
+  readonly xpathDefaultNamespace?: string;
+}
+interface OpenContent extends Annotated {
+  readonly mode?: 'none' | 'interleave' | 'suffix';
+  readonly any?: Any;
+}
+interface DefaultOpenContent extends Annotated {
+  readonly appliesToEmpty?: boolean;
+  readonly mode?: 'interleave' | 'suffix';
+  readonly any: Any;
+}
+interface Assertion extends Annotated {
+  readonly test?: string;
+  readonly xpathDefaultNamespace?: string;
+}
+interface Alternative extends Annotated {
+  readonly test?: string;
+  readonly type?: string;
+  readonly xpathDefaultNamespace?: string;
+  readonly simpleType?: LocalSimpleType;
+  readonly complexType?: LocalComplexType;
+}
+interface Notation extends Annotated {
+  readonly name: string;
+  readonly public: string;
+  readonly system?: string;
+}
+/** Element - either top-level or local */
+type Element = TopLevelElement | LocalElement;
+/** ComplexType - either top-level (named) or local (inline) */
+type ComplexType = TopLevelComplexType | LocalComplexType;
+/** SimpleType - either top-level (named) or local (inline) */
+type SimpleType = TopLevelSimpleType | LocalSimpleType;
+/** Attribute - either top-level or local */
+type Attribute = TopLevelAttribute | LocalAttribute;
+/** Group content (sequence, choice, all) */
+type Group = ExplicitGroup | All;
+//#endregion
+//#region src/codegen/types.d.ts
+/**
+ * A file to be written by the codegen system
+ */
+interface GeneratedFile {
+  /** Relative path from outputDir (e.g., 'intf.ts', 'index.ts') */
+  path: string;
+  /** File content */
+  content: string;
+}
+/**
+ * Information about a single schema being processed
+ */
+interface SchemaInfo {
+  /** Schema name (e.g., 'intf', 'classes') */
+  name: string;
+  /** Parsed XSD content */
+  xsdContent: string;
+  /** Parsed schema object */
+  schema: Schema;
+  /** Source group name (e.g., 'sap', 'custom', 'abapgit') */
+  sourceName: string;
+  /** XSD file path */
+  xsdPath: string;
+}
+/**
+ * Information about a source group
+ */
+interface SourceInfo {
+  /** Source name (e.g., 'sap', 'custom') */
+  name: string;
+  /** Directory containing XSD files */
+  xsdDir: string;
+  /** Output directory for generated files */
+  outputDir: string;
+  /** List of schema names to process */
+  schemas: string[];
+}
+/**
+ * Context passed to setup() - before any schemas are processed
+ */
+interface SetupContext {
+  /** All configured sources */
+  sources: Record<string, SourceInfo>;
+  /** Root directory (where config file is located) */
+  rootDir: string;
+}
+/**
+ * Context passed to transform() - for each schema
+ */
+interface TransformContext {
+  /** Current schema being processed */
+  schema: SchemaInfo;
+  /** Source this schema belongs to */
+  source: SourceInfo;
+  /** All schemas in this source (for import resolution) */
+  allSchemas: Map<string, SchemaInfo>;
+  /** All sources (for cross-source import resolution) */
+  allSources: Record<string, SourceInfo>;
+  /** Root directory */
+  rootDir: string;
+  /** Resolve import path for a schema location */
+  resolveImport: (schemaLocation: string) => string | null;
+}
+/**
+ * Context passed to finalize() - after all schemas are processed
+ */
+interface FinalizeContext {
+  /** All processed schemas grouped by source */
+  processedSchemas: Map<string, SchemaInfo[]>;
+  /** All sources */
+  sources: Record<string, SourceInfo>;
+  /** Root directory */
+  rootDir: string;
+}
+/**
+ * Generator plugin interface
+ *
+ * Generators are composable - multiple generators can be used together.
+ * Each generator can:
+ * - setup(): Initialize state before processing
+ * - transform(): Generate files for each schema
+ * - finalize(): Generate aggregate files after all schemas
+ */
+interface GeneratorPlugin {
+  /** Unique name for this generator */
+  readonly name: string;
+  /**
+   * Called once before processing any schemas.
+   * Use for initialization, validation, etc.
+   */
+  setup?(ctx: SetupContext): void | Promise<void>;
+  /**
+   * Called for each schema file.
+   * Return generated files for this schema.
+   */
+  transform?(ctx: TransformContext): GeneratedFile[] | Promise<GeneratedFile[]>;
+  /**
+   * Called once after all schemas are processed.
+   * Use for generating index files, aggregate types, etc.
+   */
+  finalize?(ctx: FinalizeContext): GeneratedFile[] | Promise<GeneratedFile[]>;
+}
+/**
+ * Source configuration
+ */
+interface SourceConfig {
+  /** Directory containing XSD files (relative to config file) */
+  xsdDir: string;
+  /** Output directory for generated files (relative to config file) */
+  outputDir: string;
+  /** List of schema names to process (without .xsd extension) */
+  schemas: string[];
+  /**
+   * Automatically discover and include all dependent schemas referenced via
+   * xs:import, xs:include, xs:redefine schemaLocation attributes.
+   * When enabled, you only need to list entry-point schemas - all dependencies
+   * will be discovered and generated automatically.
+   */
+  autoLink?: boolean;
+}
+/**
+ * Hook context for beforeAll/afterAll
+ */
+interface HookContext {
+  /** All configured sources */
+  sources: Record<string, SourceInfo>;
+  /** Root directory (where config file is located) */
+  rootDir: string;
+}
+/**
+ * Hook context for afterAll with results
+ */
+interface AfterAllContext extends HookContext {
+  /** All processed schemas grouped by source */
+  processedSchemas: Map<string, SchemaInfo[]>;
+  /** All generated files */
+  generatedFiles: GeneratedFile[];
+}
+/**
+ * Codegen configuration
+ */
+interface CodegenConfig {
+  /** Schema sources to process */
+  sources: Record<string, SourceConfig>;
+  /** Generator plugins to run */
+  generators: GeneratorPlugin[];
+  /** Import extension for generated files: '.ts' for Node.js native, '' for bundlers (default: '' for bundler compatibility) */
+  importExtension?: '.ts' | '';
+  /** Clean output directories before generation (default: false) */
+  clean?: boolean;
+  /** Features to enable for all generators */
+  features?: {
+    /** Include $xmlns in output */
+    $xmlns?: boolean;
+    /** Include $imports in output */
+    $imports?: boolean;
+    /** Include $filename in output */
+    $filename?: boolean;
+  };
+  /** Properties to exclude from output */
+  exclude?: string[];
+  /**
+   * Hook called before any processing starts.
+   * Use for setup, validation, cleaning output dirs, etc.
+   */
+  beforeAll?(ctx: HookContext): void | Promise<void>;
+  /**
+   * Hook called after all processing is complete.
+   * Use for generating aggregate files, post-processing, etc.
+   * Return additional files to write.
+   */
+  afterAll?(ctx: AfterAllContext): GeneratedFile[] | void | Promise<GeneratedFile[] | void>;
+}
+/**
+ * Define a codegen configuration with type checking
+ */
+declare function defineConfig(config: CodegenConfig): CodegenConfig;
+//#endregion
+//#region src/xsd/resolve.d.ts
+/** Options for schema resolution */
+interface ResolveOptions {
+  /** Resolve xs:import - merge types from imported schemas (default: true) */
+  resolveImports?: boolean;
+  /** Resolve xs:include - merge content from included schemas (default: true) */
+  resolveIncludes?: boolean;
+  /** Expand complexContent/extension - flatten inheritance (default: true) */
+  expandExtensions?: boolean;
+  /** Expand substitutionGroup - replace abstract refs with concrete elements (default: true) */
+  expandSubstitutions?: boolean;
+  /** Filter to root elements only - exclude abstract and referenced elements (default: false) */
+  filterToRootElements?: boolean;
+  /** Keep original $imports array for reference (default: false) */
+  keepImportsRef?: boolean;
+}
+/**
+ * Resolve a schema by merging all imports/includes and expanding all references.
+ * Returns a new self-contained schema with no external dependencies.
+ */
+declare function resolveSchema(schema: Schema, options?: ResolveOptions): Schema;
+/**
+ * Get all substitutes for an abstract element.
+ */
+declare function getSubstitutes(abstractElementName: string, schema: Schema): TopLevelElement[];
+//#endregion
+//#region src/codegen/runner.d.ts
+interface RunnerOptions {
+  /** Root directory (where config file is located) */
+  rootDir: string;
+  /** Dry run - don't write files, just return what would be written */
+  dryRun?: boolean;
+  /** Verbose logging */
+  verbose?: boolean;
+}
+interface RunnerResult {
+  /** Files that were written (or would be written in dry run) */
+  files: Array<{
+    path: string;
+    source: string;
+  }>;
+  /** Schemas that were processed */
+  schemas: Array<{
+    name: string;
+    source: string;
+  }>;
+  /** Errors that occurred */
+  errors: Array<{
+    schema?: string;
+    source?: string;
+    error: Error;
+  }>;
+}
+/**
+ * Run the codegen pipeline
+ */
+declare function runCodegen(config: CodegenConfig, options: RunnerOptions): Promise<RunnerResult>;
+//#endregion
+export { Notation as $, ComplexContentExtension as A, Group as B, Any as C, Attribute as D, Assertion as E, Element as F, Keyref as G, Import as H, ExplicitGroup as I, LocalComplexType as J, List as K, Facet as L, ComplexType as M, DefaultOpenContent as N, AttributeGroupRef as O, Documentation as P, NamedGroup as Q, Field as R, Annotation as S, Appinfo as T, Include as U, GroupRef as V, Key as W, LocalSimpleType as X, LocalElement as Y, NamedAttributeGroup as Z, TransformContext as _, Union as _t, getSubstitutes as a, Schema as at, Alternative as b, CodegenConfig as c, SimpleContent as ct, GeneratorPlugin as d, SimpleType as dt, OpenAttrs as et, HookContext as f, SimpleTypeRestriction as ft, SourceInfo as g, TopLevelSimpleType as gt, SourceConfig as h, TopLevelElement as ht, ResolveOptions as i, Redefine as it, ComplexContentRestriction as j, ComplexContent as k, FinalizeContext as l, SimpleContentExtension as lt, SetupContext as m, TopLevelComplexType as mt, RunnerResult as n, Override as nt, resolveSchema as o, SchemaAttrs as ot, SchemaInfo as p, TopLevelAttribute as pt, LocalAttribute as q, runCodegen as r, Pattern as rt, AfterAllContext as s, Selector as st, RunnerOptions as t, OpenContent as tt, GeneratedFile as u, SimpleContentRestriction as ut, defineConfig as v, Unique as vt, AnyAttribute as w, Annotated as x, All as y, XmlnsDeclarations as yt, FormChoice as z };
+//# sourceMappingURL=runner-D1RCU_go.d.mts.map