import { JSONSchema7Definition } from "json-schema";
import { ILanguageConverter, IRNode } from "../types.js";
import { BaseConverterContext, BaseConverterOpts, GenerateTypeUtils, LanguageProfile } from "../converter/BaseConverter.js";
import { KotlinBaseConverter } from "./KotlinBaseConverter.js";
export interface KotlinConverterOpts extends BaseConverterOpts {
    serializer?: "kotlinx" | "none";
    packageName?: string;
    /**
     * When true, nested object types are emitted as nested `data class`
     * declarations inside their parent's body block, scoped to the parent's
     * namespace:
     *
     *     data class Body(val address: Address, ...) {
     *       data class Address(val street: String, ...)
     *     }
     *
     * rather than as top-level sibling declarations. Useful when emitting
     * multiple sibling schemas into one outer Kotlin `object` namespace —
     * each parent's `Address` is name-scoped (`Body.Address` vs
     * `Response.Address`), eliminating cross-call collisions structurally.
     *
     * Default: `false` (extract to top-level siblings — the historical
     * behavior). Top-level enums and discriminated unions remain extracted
     * even when `inlineTypes` is `true`.
     */
    inlineTypes?: boolean;
}
/**
 * The state-and-method surface that helper modules in `src/kotlin/` need to
 * operate on a KotlinConverter instance. KotlinConverter implements this;
 * helpers take it as their first argument.
 *
 * @internal
 */
export interface KotlinConverterContext extends BaseConverterContext {
    readonly isKotlinx: boolean;
    readonly inlineTypes: boolean;
    readonly importsSet: Set<string>;
    readonly contextualNodes: WeakSet<IRNode>;
    readonly docFormatNodes: WeakMap<IRNode, string>;
    readonly propertySerialNames: WeakMap<IRNode, string>;
    readonly enumDecls: Map<string, {
        name: string;
        values: string[];
    }>;
    readonly sealedDecls: string[];
    generateType(ir: IRNode, utils: GenerateTypeUtils): string;
    emitSealedInterface(ir: IRNode, utils: GenerateTypeUtils): string;
}
export declare class KotlinConverter extends KotlinBaseConverter implements ILanguageConverter, KotlinConverterContext {
    readonly code: string;
    readonly rootTypeName: string;
    readonly extractedTypeNames: string[];
    readonly imports: string[];
    readonly referencedNamedTypes: string[];
    /** @internal Public for `BaseConverterContext`; treat as protected for subclasses. */
    readonly languageProfile: LanguageProfile;
    /** @internal Mutated by KotlinConverter helper modules; not part of the public API. */
    isKotlinx: boolean;
    /** @internal */
    inlineTypes: boolean;
    /** @internal */
    enumDecls: Map<string, {
        name: string;
        values: string[];
    }>;
    /** @internal */
    propertySerialNames: WeakMap<IRNode, string>;
    /** @internal */
    contextualNodes: WeakSet<IRNode>;
    /** @internal */
    docFormatNodes: WeakMap<IRNode, string>;
    /** @internal */
    sealedDecls: string[];
    constructor(schema: JSONSchema7Definition, opts?: KotlinConverterOpts);
    /** @internal Public for `KotlinConverterContext`; treat as protected for subclasses. */
    generateType(ir: IRNode, utils: GenerateTypeUtils): string;
    /** @internal Public for `BaseConverterContext`; treat as protected for subclasses. */
    generateObjectType(ir: IRNode, utils: GenerateTypeUtils): string;
    /** @internal Public for `KotlinConverterContext`; treat as protected for subclasses. */
    emitSealedInterface(ir: IRNode, utils: GenerateTypeUtils): string;
    /**
     * Assembles the final Kotlin source by joining the (optional) `package` line
     * and a list of top-level declarations with blank-line separators, terminated
     * by a trailing newline. Uses {@link Emitter} for indent/block tracking
     * (Kotlin top-level decls are at indent 0, so this is essentially a join,
     * but keeps assembly consistent with other language emitters).
     */
    private assembleCode;
}