/**
 * Synthetic Type Generation for Union-of-Object-Literals
 *
 * When a type alias contains a union of object literal types, we generate
 * synthetic nominal interfaces for each object member. This enables:
 * - TSN7403 compliance (object literals have contextual nominal types)
 * - Proper C# emission (nominal types instead of anonymous objects)
 *
 * Example:
 *   type Result<T, E> = { ok: true; value: T } | { ok: false; error: E };
 *
 * Generates:
 *   interface Result__0<T, E> { ok: true; value: T }
 *   interface Result__1<T, E> { ok: false; error: E }
 *   type Result<T, E> = Result__0<T, E> | Result__1<T, E>
 */
import { IrInterfaceDeclaration, IrTypeAliasDeclaration } from "../types.js";
/**
 * Result of processing a type alias for synthetic type generation
 */
export type SyntheticTypeResult = {
    /** The (possibly rewritten) type alias declaration */
    readonly typeAlias: IrTypeAliasDeclaration;
    /** Generated synthetic interface declarations (empty if no rewriting needed) */
    readonly syntheticInterfaces: readonly IrInterfaceDeclaration[];
};
/**
 * Process a type alias declaration and generate synthetic interfaces if needed.
 *
 * If the type alias is a union containing object literal types, this will:
 * 1. Generate a synthetic interface for each object literal member
 * 2. Rewrite the union to use reference types to the synthetics
 * 3. Return both the rewritten alias and the synthetic interfaces
 *
 * If no object literals are found, returns the original alias unchanged.
 */
export declare const processTypeAliasForSynthetics: (typeAlias: IrTypeAliasDeclaration) => SyntheticTypeResult;
//# sourceMappingURL=synthetic-types.d.ts.map