import type { ComponentGraphIRDoc } from "../ir-handle.js";
import { type GenerateOptions } from "../generator/index.js";
/**
 * CliCodegenOptions — the emitter options the CLI FLAGS resolve, i.e. every {@link GenerateOptions} field
 * a flag can carry. The two fields that are NOT here are supplied by the DECLARATION, not by a flag:
 *   - `namespace` — the declaring class (`--behavior`), added by the `--from` seam below (§5.5 rule 2:
 *     the class name IS the namespace, so a flag would be a second truth).
 *   - `ioModel` — the `@leaf` async declaration, read off the compiled handle by `generateModule`.
 * A new GenerateOptions field must land in one of the three routes or the reachability gate goes RED.
 */
export type CliCodegenOptions = Omit<GenerateOptions, "namespace" | "ioModel">;
/** `--in` covered path: a serialized IR doc → the native module source (same emit as the in-process API).
 * Adopts the unbranded doc via the internal {@link adoptIrDoc} seam (validate + mint), then hands the
 * compiled IR to the shared {@link emitCovered} seam. `--in` is a BUILD-TIME input the developer passes on
 * the command line — a bare IR JSON with no baked fingerprint — so it is not the runtime boundary the
 * public `loadCompiledIR` guards (that one requires the fingerprint the generated module baked in). */
export declare function generateFromDoc(doc: ComponentGraphIRDoc, options: CliCodegenOptions): string;
/**
 * `--from` covered path (the TS-authoring codegen entry — ts→ir→native一気通貫). Compiles the consumer's
 * `--behavior` class to IR via {@link compileFromModule}, then hands that IR to the SAME {@link emitCovered}
 * seam `--in` uses (no emit reimplementation). The IR is produced and consumed entirely inside the CLI — it
 * never crosses the consumer surface.
 */
export declare function generateFromModule(fromPath: string, behaviorName: string, options: CliCodegenOptions): Promise<string>;
/** `--in` shared-types path: a serialized IR doc → the BC-OWNED shared wire types module (the same one the
 * covered module imports when generated with --shared-types-import). Adopts via the SAME {@link adoptIrDoc}
 * seam the covered `--in` path uses, then hands off to the shared {@link emitSharedTypes} seam. */
export declare function generateSharedTypesFromDoc(doc: ComponentGraphIRDoc, language: string, sharedTypesImport?: string): string;
/** `--from` shared-types path: compile the consumer's behavior module via the SAME {@link compileFromModule}
 * seam, and emit the BC-owned shared wire types module over the SAME {@link emitSharedTypes} seam `--in` uses. */
export declare function generateSharedTypesFromModule(fromPath: string, behaviorName: string, language: string, sharedTypesImport?: string): Promise<string>;
/** Read + parse a serialized ComponentGraphIRDoc from disk. */
export declare function readDoc(inPath: string): ComponentGraphIRDoc;
//# sourceMappingURL=codegen.d.ts.map