ajsc 5.2.4 → 7.1.0

package/dist/converter/BaseConverter.d.ts

@@ -0,0 +1,315 @@
+import { ILanguageConverter, IRNode, SignatureOccurrenceValue } from "../types.js";
+export { walkIR } from "./walk.js";
+export type RefTypeName = string;
+export interface RefTypeEntry {
+    signature: SignatureOccurrenceValue["signature"];
+    name: RefTypeName;
+    code: string;
+    title?: string;
+    description?: string;
+    doc?: string;
+}
+export type RefTypes = RefTypeEntry[];
+/**
+ * Per-language configuration bundle. Each language subclass declares one
+ * `languageProfile` field; the base class reads from it instead of calling
+ * a method-per-knob. Optional fields fall through to the base default.
+ */
+export interface LanguageProfile {
+    /** Language identifier emitted as `language` on the converter. */
+    language: string;
+    /**
+     * When true, `getReferencedType` short-circuits IR nodes whose `name` matches
+     * the root name back to a direct self-reference (so e.g. a `Tree` schema with
+     * `children: Array<{$ref: "#"}>` emits as `children: Array<Tree>` rather than
+     * extracting a duplicate `Child` type). Default: true. All current languages
+     * use the default; this hook exists for hypothetical future targets that want
+     * a different recursion shape.
+     */
+    detectSelfReferenceToRoot?: boolean;
+    /**
+     * When true, `enhanceDiscriminatedUnions` ALSO walks `oneOf` unions (in addition
+     * to `anyOf`). Default: false. Languages that emit a tagged-union form for `oneOf`
+     * (Kotlin sealed interface, Swift enum w/ associated values) override to true.
+     */
+    processOneOfAsDiscriminatedUnion?: boolean;
+    /**
+     * When true, `applyDiscriminatedUnionEnhancements` populates `discriminatorInfo`
+     * for downstream consolidated enum emission. Default: false. TS overrides based
+     * on `enumStyle === "enum" && !inlineTypes`.
+     */
+    shouldPopulateDiscriminatorInfo?: boolean;
+    /**
+     * When true, `stripDiscriminatorField` removes the discriminator key from variant
+     * payload bodies (because the language hoists it into a tag annotation or codable
+     * plumbing). Default: false. Kotlin = `isKotlinx`. Swift = `isCodable`.
+     */
+    shouldEraseDiscriminator?: boolean;
+    /**
+     * Custom ref-type naming configuration. Merged shallow over the BaseConverter default
+     * (postfix list, depluralize, etc.). Useful for adding language-specific postfixes
+     * (e.g. "Enum" in TS).
+     */
+    refTypeNamingConfig?: Partial<RefTypeNamingConfig>;
+    /**
+     * Parent-name component used by `applyDiscriminatedUnionEnhancements` when deriving
+     * variant names. Default: last non-numeric segment of `ir.path`. Kotlin extends this
+     * with a fallback to `ir.name || ir.title`; Swift always returns "" (variants are
+     * nested in the enum, no parent suffix needed).
+     */
+    getDiscriminatedVariantParentName?: (ir: IRNode) => string;
+    /**
+     * Override ref-type name resolution. `defaultResolver()` invokes the path-based
+     * default. TS uses this to apply enum-style overrides.
+     */
+    resolveRefTypeName?: (ir: IRNode, signature: string, defaultResolver: () => string) => string;
+    /**
+     * Language-specific signature dedup decision. Default: false. TS = `dedupSignatures.has(sig)`.
+     */
+    shouldReuseExistingSignature?: (signature: string) => boolean;
+}
+export interface RefTypeNamingConfig {
+    /** Base postfixes to try for name collision resolution */
+    postfixes: string[];
+    /** If true, singularize array item path segments (e.g. "entries" → "entry", "people" → "person") */
+    depluralize?: boolean;
+    /** If true, handle "*" path endings with AnyKey/AnyProperty postfixes */
+    handleAnySymbol?: boolean;
+    /** If true, strip leading "*" from proposed names */
+    stripLeadingAnySymbol?: boolean;
+    /**
+     * Controls the postfix added to array item type names.
+     * - `false` (default) → no postfix, uses property name directly
+     * - `string` → custom postfix (e.g. "Item" → ContactsItem, "Element" → ContactsElement)
+     */
+    arrayItemNaming?: string | false;
+    /**
+     * Additional words that should not be singularized when `depluralize` is true.
+     * Built-in uncountables: "data", "metadata".
+     * @example ["criteria", "alumni", "corpus"]
+     */
+    uncountableWords?: string[];
+}
+export type GenerateTypeUtils = {
+    getReferencedType(ir: IRNode): string | undefined;
+};
+/**
+ * The state-and-method surface that helper modules in `src/converter/`
+ * need to operate on a BaseConverter instance. BaseConverter implements
+ * this; helpers take it as their first argument.
+ *
+ * Using this interface (rather than the BaseConverter class itself) keeps
+ * helper modules from depending on the abstract class shape — they only
+ * see the concrete contract they need.
+ *
+ * @internal
+ */
+export interface BaseConverterContext {
+    readonly refTypes: RefTypeEntry[];
+    readonly usedDeclarationNames: Set<string>;
+    rootName?: string;
+    rootDoc?: string;
+    baseOpts?: BaseConverterOpts;
+    readonly variantNames: Map<IRNode, string>;
+    readonly discriminatorInfo: Map<IRNode, {
+        allValues: string[];
+        thisValue: string;
+    }>;
+    readonly dedupSignatures: Set<string>;
+    mergeCounter: number;
+    /** Used internally by `getUniqueRefTypeName`; exposed for the helper to mutate. */
+    fallbackCounter: number;
+    readonly languageProfile: LanguageProfile;
+    /** Subclass-implemented; called by `getReferencedType` after registering an entry. */
+    generateObjectType(ir: IRNode, utils: GenerateTypeUtils): string;
+    /** Returns a name not already in `usedDeclarationNames`, suffixing as needed. */
+    findAvailableName(base: string): string;
+    /** Locates a const-string discriminator property across union options. */
+    findDiscriminatorProperty(options: IRNode[], sharedPropNames: string[]): string | null;
+    /** Computes shared and combined property names across union options. */
+    collectUnionPropertyNames(options: IRNode[]): {
+        allPropNames: string[];
+        sharedPropNames: string[];
+    };
+    /** Returns a clone of `opt` with the discriminator property removed. */
+    stripDiscriminatorField(opt: IRNode, discriminator: string): IRNode;
+    /** Returns the const string value of an enum/literal IR, if any. */
+    getConstStringValue(ir: IRNode | undefined): string | undefined;
+}
+export interface BaseConverterOpts {
+    /** Overrides the IR root name (which defaults to schema.title or "Root"). */
+    rootTypeName?: string;
+    /**
+     * Controls the postfix added to array item type names.
+     * - `false` (default) → no postfix, uses property name directly
+     * - `string` → custom postfix (e.g. "Item" → ContactsItem, "Element" → ContactsElement)
+     */
+    arrayItemNaming?: string | false;
+    /**
+     * If true (default), singularize array item path segments when generating type names.
+     */
+    depluralize?: boolean;
+    /**
+     * Additional words that should not be singularized when `depluralize` is true.
+     */
+    uncountableWords?: string[];
+    /**
+     * How to handle unions that survive merging with no discriminator.
+     * - `"throw"` (default) — throw with a path-bearing message
+     * - `"fallback"` — emit a language-specific fallback type (added in later tasks)
+     */
+    unsupportedUnions?: "throw" | "fallback";
+    /**
+     * Shared registry of declaration names already emitted. When provided,
+     * the converter uses this Set as its `usedDeclarationNames` and mutates
+     * it as new types are emitted. Pass the same Set across multiple emit
+     * calls to avoid duplicate-name compile errors when the resulting code
+     * blocks are concatenated into one Kotlin/Swift namespace.
+     *
+     * Names that collide across calls fall through the standard collision-
+     * resolution path (parent path escalation, postfix list, then a numeric
+     * suffix). Pair with {@link namePrefix} for cleaner per-slot names.
+     *
+     * Most useful for Kotlin and Swift, which require named declarations for
+     * all non-primitive types. Harmless for TypeScript, which can use
+     * `inlineTypes: true` to flatten nested types instead.
+     */
+    nameRegistry?: Set<string>;
+    /**
+     * Optional synthetic component prepended to every extracted (nested)
+     * type name during ref-type naming. With `namePrefix: "Body"`, a nested
+     * `address` field extracts as `BodyAddress` instead of `Address`.
+     *
+     * Useful when emitting multiple sibling schemas that share an output
+     * namespace — pair with {@link nameRegistry} and a per-slot
+     * {@link rootTypeName} to avoid all cross-call collisions.
+     *
+     * Does not affect the root type name (use `rootTypeName` for that).
+     * The prefix is sanitized via PascalCase, so non-identifier characters
+     * are stripped.
+     */
+    namePrefix?: string;
+}
+export declare abstract class BaseConverter implements Partial<ILanguageConverter>, BaseConverterContext {
+    abstract readonly code: string;
+    /** @internal Public for `BaseConverterContext`; treat as protected for subclasses. */
+    abstract readonly languageProfile: LanguageProfile;
+    abstract readonly rootTypeName: string;
+    abstract readonly extractedTypeNames: string[];
+    abstract readonly imports: string[];
+    get language(): string;
+    /** @internal Public for `BaseConverterContext`; treat as protected for subclasses. */
+    refTypes: RefTypes;
+    /**
+     * Shared registry of all top-level declaration names (types + enums) for cross-namespace collision detection.
+     * @internal Public for `BaseConverterContext`; treat as protected for subclasses.
+     */
+    usedDeclarationNames: Set<string>;
+    /**
+     * Root schema name, used as fallback context for root-level array item naming.
+     * @internal Public for `BaseConverterContext`; treat as protected for subclasses.
+     */
+    rootName?: string;
+    /**
+     * Optional doc note attached to the root type declaration. Populated by
+     * subclasses (e.g. for additionalProperties annotations) since the root
+     * type is not held in the refTypes registry.
+     * @internal Public for `BaseConverterContext`; treat as protected for subclasses.
+     */
+    rootDoc?: string;
+    /**
+     * Shared options available to all language converters.
+     * @internal Public for `BaseConverterContext`; treat as protected for subclasses.
+     */
+    baseOpts?: BaseConverterOpts;
+    /** @internal Public for `BaseConverterContext`; treat as private. */
+    fallbackCounter: number;
+    /** @internal Public for `BaseConverterContext`; treat as protected for subclasses. */
+    mergeCounter: number;
+    /**
+     * Maps discriminator literal IR nodes to their consolidated enum info.
+     * Used by generateLiteralType and preRegisterEnumNames to emit a single
+     * consolidated enum and member references instead of single-value enums.
+     * @internal Public for `BaseConverterContext`; treat as protected for subclasses.
+     */
+    discriminatorInfo: Map<IRNode, {
+        allValues: string[];
+        thisValue: string;
+    }>;
+    /**
+     * Maps variant IR nodes to their enhancement-assigned names.
+     * @internal Public for `BaseConverterContext`; treat as protected for subclasses.
+     */
+    variantNames: Map<IRNode, string>;
+    /**
+     * Signatures eligible for cross-variant deduplication.
+     * @internal Public for `BaseConverterContext`; treat as protected for subclasses.
+     */
+    dedupSignatures: Set<string>;
+    /**
+     * Returns names of all extracted ref types in declaration order.
+     * Subclasses may filter further (e.g. to exclude the root type).
+     */
+    protected computeExtractedTypeNames(): string[];
+    /** Path-derived, collision-free ref type name. Delegates to `naming.ts`. */
+    protected getUniqueRefTypeName(signature: string, nodePath: string): RefTypeName;
+    /**
+     * Each language subclass must implement object-literal emission.
+     * `getReferencedType` calls this when registering a new ref type.
+     * @internal Public for `BaseConverterContext`; treat as protected for subclasses.
+     */
+    abstract generateObjectType(ir: IRNode, utils: GenerateTypeUtils): string;
+    /** Resolves an IR node to its registered ref-type name. Delegates to `registry.ts`. */
+    protected getReferencedType(ir: IRNode): string | undefined;
+    /**
+     * Recursively walks the IR tree (bottom-up) and merges anyOf unions
+     * whose options are all objects with compatible property types.
+     * Delegates to `mergeUnions.ts`.
+     */
+    protected mergeCompatibleUnions(ir: IRNode): IRNode;
+    /** Delegates to `mergeUnions.ts`. */
+    protected tryMergeObjectUnion(ir: IRNode): IRNode | null;
+    /** Delegates to `mergeUnions.ts`. */
+    protected tryMergeProperty(instances: IRNode[]): IRNode | null;
+    /** Delegates to `mergeUnions.ts`. */
+    protected isDiscriminatedUnion(options: IRNode[], sharedPropNames: string[], allPropNames: string[]): boolean;
+    /**
+     * Walks the IR tree and applies discriminated union enhancements
+     * to anyOf unions that survived merging. Delegates to `discriminatedUnions.ts`.
+     */
+    protected enhanceDiscriminatedUnions(ir: IRNode): void;
+    /**
+     * Delegates to `discriminatedUnions.ts`.
+     * @internal Public for `BaseConverterContext`; treat as protected for subclasses.
+     */
+    stripDiscriminatorField(opt: IRNode, discriminator: string): IRNode;
+    /**
+     * Returns `base` if it is not already taken in `usedDeclarationNames`,
+     * otherwise appends an incrementing suffix (`base2`, `base3`, …) until a
+     * free name is found. Subclasses use this for collision-free declaration
+     * names where path-derived disambiguation is not appropriate (e.g. enum
+     * names derived from a property name).
+     * @internal Public for `BaseConverterContext`; treat as protected for subclasses.
+     */
+    findAvailableName(base: string): string;
+    /** Delegates to `discriminatedUnions.ts`. */
+    protected applyDiscriminatedUnionEnhancements(ir: IRNode): void;
+    /**
+     * Delegates to `discriminatedUnions.ts`.
+     * @internal Public for `BaseConverterContext`; treat as protected for subclasses.
+     */
+    collectUnionPropertyNames(options: IRNode[]): {
+        allPropNames: string[];
+        sharedPropNames: string[];
+    };
+    /**
+     * Delegates to `discriminatedUnions.ts`.
+     * @internal Public for `BaseConverterContext`; treat as protected for subclasses.
+     */
+    findDiscriminatorProperty(options: IRNode[], sharedPropNames: string[]): string | null;
+    /**
+     * Delegates to `discriminatedUnions.ts`.
+     * @internal Public for `BaseConverterContext`; treat as protected for subclasses.
+     */
+    getConstStringValue(ir: IRNode | undefined): string | undefined;
+}

package/dist/converter/BaseConverter.js

@@ -0,0 +1,131 @@
+import { computeExtractedTypeNames, getUniqueRefTypeName, } from "./naming.js";
+import { getReferencedType } from "./registry.js";
+import { isDiscriminatedUnion, mergeCompatibleUnions, tryMergeObjectUnion, tryMergeProperty, } from "./mergeUnions.js";
+import { applyDiscriminatedUnionEnhancements, collectUnionPropertyNames, enhanceDiscriminatedUnions, findDiscriminatorProperty, getConstStringValue, stripDiscriminatorField, } from "./discriminatedUnions.js";
+export { walkIR } from "./walk.js";
+export class BaseConverter {
+    constructor() {
+        /** @internal Public for `BaseConverterContext`; treat as protected for subclasses. */
+        this.refTypes = [];
+        /**
+         * Shared registry of all top-level declaration names (types + enums) for cross-namespace collision detection.
+         * @internal Public for `BaseConverterContext`; treat as protected for subclasses.
+         */
+        this.usedDeclarationNames = new Set();
+        /** @internal Public for `BaseConverterContext`; treat as private. */
+        this.fallbackCounter = 0;
+        /** @internal Public for `BaseConverterContext`; treat as protected for subclasses. */
+        this.mergeCounter = 0;
+        /**
+         * Maps discriminator literal IR nodes to their consolidated enum info.
+         * Used by generateLiteralType and preRegisterEnumNames to emit a single
+         * consolidated enum and member references instead of single-value enums.
+         * @internal Public for `BaseConverterContext`; treat as protected for subclasses.
+         */
+        this.discriminatorInfo = new Map();
+        /**
+         * Maps variant IR nodes to their enhancement-assigned names.
+         * @internal Public for `BaseConverterContext`; treat as protected for subclasses.
+         */
+        this.variantNames = new Map();
+        /**
+         * Signatures eligible for cross-variant deduplication.
+         * @internal Public for `BaseConverterContext`; treat as protected for subclasses.
+         */
+        this.dedupSignatures = new Set();
+    }
+    get language() {
+        return this.languageProfile.language;
+    }
+    /**
+     * Returns names of all extracted ref types in declaration order.
+     * Subclasses may filter further (e.g. to exclude the root type).
+     */
+    computeExtractedTypeNames() {
+        return computeExtractedTypeNames(this);
+    }
+    /** Path-derived, collision-free ref type name. Delegates to `naming.ts`. */
+    getUniqueRefTypeName(signature, nodePath) {
+        return getUniqueRefTypeName(this, signature, nodePath);
+    }
+    /** Resolves an IR node to its registered ref-type name. Delegates to `registry.ts`. */
+    getReferencedType(ir) {
+        return getReferencedType(this, ir);
+    }
+    /**
+     * Recursively walks the IR tree (bottom-up) and merges anyOf unions
+     * whose options are all objects with compatible property types.
+     * Delegates to `mergeUnions.ts`.
+     */
+    mergeCompatibleUnions(ir) {
+        return mergeCompatibleUnions(this, ir);
+    }
+    /** Delegates to `mergeUnions.ts`. */
+    tryMergeObjectUnion(ir) {
+        return tryMergeObjectUnion(this, ir);
+    }
+    /** Delegates to `mergeUnions.ts`. */
+    tryMergeProperty(instances) {
+        return tryMergeProperty(instances);
+    }
+    /** Delegates to `mergeUnions.ts`. */
+    isDiscriminatedUnion(options, sharedPropNames, allPropNames) {
+        return isDiscriminatedUnion(options, sharedPropNames, allPropNames);
+    }
+    /**
+     * Walks the IR tree and applies discriminated union enhancements
+     * to anyOf unions that survived merging. Delegates to `discriminatedUnions.ts`.
+     */
+    enhanceDiscriminatedUnions(ir) {
+        enhanceDiscriminatedUnions(this, ir);
+    }
+    /**
+     * Delegates to `discriminatedUnions.ts`.
+     * @internal Public for `BaseConverterContext`; treat as protected for subclasses.
+     */
+    stripDiscriminatorField(opt, discriminator) {
+        return stripDiscriminatorField(this, opt, discriminator);
+    }
+    /**
+     * Returns `base` if it is not already taken in `usedDeclarationNames`,
+     * otherwise appends an incrementing suffix (`base2`, `base3`, …) until a
+     * free name is found. Subclasses use this for collision-free declaration
+     * names where path-derived disambiguation is not appropriate (e.g. enum
+     * names derived from a property name).
+     * @internal Public for `BaseConverterContext`; treat as protected for subclasses.
+     */
+    findAvailableName(base) {
+        if (!this.usedDeclarationNames.has(base))
+            return base;
+        let i = 2;
+        while (this.usedDeclarationNames.has(base + i))
+            i++;
+        return base + i;
+    }
+    /** Delegates to `discriminatedUnions.ts`. */
+    applyDiscriminatedUnionEnhancements(ir) {
+        applyDiscriminatedUnionEnhancements(this, ir);
+    }
+    /**
+     * Delegates to `discriminatedUnions.ts`.
+     * @internal Public for `BaseConverterContext`; treat as protected for subclasses.
+     */
+    collectUnionPropertyNames(options) {
+        return collectUnionPropertyNames(options);
+    }
+    /**
+     * Delegates to `discriminatedUnions.ts`.
+     * @internal Public for `BaseConverterContext`; treat as protected for subclasses.
+     */
+    findDiscriminatorProperty(options, sharedPropNames) {
+        return findDiscriminatorProperty(options, sharedPropNames);
+    }
+    /**
+     * Delegates to `discriminatedUnions.ts`.
+     * @internal Public for `BaseConverterContext`; treat as protected for subclasses.
+     */
+    getConstStringValue(ir) {
+        return getConstStringValue(ir);
+    }
+}
+//# sourceMappingURL=BaseConverter.js.map

package/dist/converter/BaseConverter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseConverter.js","sourceRoot":"","sources":["../../src/converter/BaseConverter.ts"],"names":[],"mappings":"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"}

package/dist/converter/Emitter.d.ts

@@ -0,0 +1,35 @@
+export interface EmitterOptions {
+    /**
+     * Indentation unit (string repeated per nesting level). Defaults to two spaces.
+     * Common values: `"  "` (2 spaces, Kotlin convention), `"    "` (4 spaces, Swift).
+     */
+    indentUnit?: string;
+}
+/**
+ * Indent-aware string builder for code emission. Tracks nesting depth via
+ * `block()` and emits a single line at the current depth via `line()`.
+ *
+ * Designed so that all current Kotlin/Swift output can be reproduced without
+ * any hardcoded pad strings inside the emit logic.
+ */
+export declare class Emitter {
+    private readonly indentUnit;
+    private currentIndent;
+    private readonly lines;
+    constructor(opts?: EmitterOptions);
+    /** Emit a line at the current indent. Empty string emits a blank line with no indent. */
+    line(s?: string): this;
+    /** Emit a blank line (no indent). */
+    blank(): this;
+    /**
+     * Emit `header + " {"`, then run `body` at one deeper indent, then emit `footer`.
+     * Footer defaults to `"}"`.
+     */
+    block(header: string, body: () => void, footer?: string): this;
+    /**
+     * Emit pre-formatted multi-line content at current indent. Each non-empty
+     * source line is prefixed with the current indent; empty source lines stay empty.
+     */
+    raw(s: string): this;
+    toString(): string;
+}

package/dist/converter/Emitter.js

@@ -0,0 +1,50 @@
+/**
+ * Indent-aware string builder for code emission. Tracks nesting depth via
+ * `block()` and emits a single line at the current depth via `line()`.
+ *
+ * Designed so that all current Kotlin/Swift output can be reproduced without
+ * any hardcoded pad strings inside the emit logic.
+ */
+export class Emitter {
+    constructor(opts = {}) {
+        this.currentIndent = "";
+        this.lines = [];
+        this.indentUnit = opts.indentUnit ?? "  ";
+    }
+    /** Emit a line at the current indent. Empty string emits a blank line with no indent. */
+    line(s = "") {
+        this.lines.push(s.length ? this.currentIndent + s : "");
+        return this;
+    }
+    /** Emit a blank line (no indent). */
+    blank() {
+        this.lines.push("");
+        return this;
+    }
+    /**
+     * Emit `header + " {"`, then run `body` at one deeper indent, then emit `footer`.
+     * Footer defaults to `"}"`.
+     */
+    block(header, body, footer = "}") {
+        this.line(header + " {");
+        this.currentIndent += this.indentUnit;
+        body();
+        this.currentIndent = this.currentIndent.slice(0, -this.indentUnit.length);
+        this.line(footer);
+        return this;
+    }
+    /**
+     * Emit pre-formatted multi-line content at current indent. Each non-empty
+     * source line is prefixed with the current indent; empty source lines stay empty.
+     */
+    raw(s) {
+        for (const ln of s.split("\n")) {
+            this.lines.push(ln.length ? this.currentIndent + ln : "");
+        }
+        return this;
+    }
+    toString() {
+        return this.lines.join("\n");
+    }
+}
+//# sourceMappingURL=Emitter.js.map

package/dist/converter/Emitter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Emitter.js","sourceRoot":"","sources":["../../src/converter/Emitter.ts"],"names":[],"mappings":"AAQA;;;;;;GAMG;AACH,MAAM,OAAO,OAAO;IAKlB,YAAY,OAAuB,EAAE;QAH7B,kBAAa,GAAG,EAAE,CAAC;QACV,UAAK,GAAa,EAAE,CAAC;QAGpC,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,UAAU,IAAI,IAAI,CAAC;IAC5C,CAAC;IAED,yFAAyF;IACzF,IAAI,CAAC,CAAC,GAAG,EAAE;QACT,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QACxD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,qCAAqC;IACrC,KAAK;QACH,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACpB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,MAAc,EAAE,IAAgB,EAAE,MAAM,GAAG,GAAG;QAClD,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;QACzB,IAAI,CAAC,aAAa,IAAI,IAAI,CAAC,UAAU,CAAC;QACtC,IAAI,EAAE,CAAC;QACP,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;QAC1E,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAClB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;OAGG;IACH,GAAG,CAAC,CAAS;QACX,KAAK,MAAM,EAAE,IAAI,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;YAC/B,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,GAAG,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QAC5D,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,QAAQ;QACN,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC/B,CAAC;CACF"}

package/dist/converter/discriminatedUnions.d.ts

@@ -0,0 +1,47 @@
+import { IRNode } from "../types.js";
+import type { BaseConverterContext } from "./BaseConverter.js";
+/**
+ * Collects all property names (in first-seen order) and shared property names
+ * across union options.
+ *
+ * Pure helper — does not depend on any converter context.
+ */
+export declare function collectUnionPropertyNames(options: IRNode[]): {
+    allPropNames: string[];
+    sharedPropNames: string[];
+};
+/**
+ * Extracts a single const string value from an IR node (literal with string
+ * value or single-value string enum).
+ *
+ * Pure helper — does not depend on any converter context.
+ */
+export declare function getConstStringValue(ir: IRNode | undefined): string | undefined;
+/**
+ * Finds the discriminator property among shared properties: a property where
+ * each option has a distinct const or single-value-enum string value.
+ */
+export declare function findDiscriminatorProperty(options: IRNode[], sharedPropNames: string[]): string | null;
+/**
+ * Walks the IR tree and applies discriminated union enhancements
+ * to anyOf unions that survived merging. Subclasses may opt in to also
+ * process `oneOf` unions via the `processOneOfAsDiscriminatedUnion`
+ * field on `languageProfile`.
+ */
+export declare function enhanceDiscriminatedUnions(c: BaseConverterContext, ir: IRNode): void;
+/**
+ * Enhances an unmerged anyOf union that has a discriminator property.
+ * Sets `ir.name` on each variant to a discriminator-derived name and
+ * populates `discriminatorInfo` for consolidated enum emission.
+ */
+export declare function applyDiscriminatedUnionEnhancements(c: BaseConverterContext, ir: IRNode): void;
+/**
+ * Returns a copy of the variant IR node with the discriminator property removed
+ * when `languageProfile.shouldEraseDiscriminator` is true. Otherwise returns the original.
+ *
+ * Used by language emitters that hoist the discriminator into a sealed-interface
+ * annotation (Kotlin `@JsonClassDiscriminator`) or a Codable plumbing block (Swift
+ * generated `init(from:)`/`encode(to:)`), where carrying the field on the variant
+ * struct would cause a duplicate-key error during decode.
+ */
+export declare function stripDiscriminatorField(c: BaseConverterContext, opt: IRNode, discriminator: string): IRNode;