@typra/emitter 0.2.0

package/dist/src/cleanup/generated-file.d.ts

@@ -0,0 +1,6 @@
+import { EmitContext } from "@typespec/compiler";
+import { TypraEmitterOptions } from "../lib.js";
+export declare function emitGeneratedFile(context: EmitContext<TypraEmitterOptions>, filePath: string, content: string, options?: {
+    marker?: boolean;
+}): Promise<void>;
+export declare function emitGeneratedManifest(context: EmitContext<TypraEmitterOptions>): Promise<void>;

package/dist/src/cleanup/generated-file.js

@@ -0,0 +1,61 @@
+import { emitFile, resolvePath } from "@typespec/compiler";
+import { dirname, relative, resolve } from "path";
+const generatedFilesByProgram = new WeakMap();
+export async function emitGeneratedFile(context, filePath, content, options = {}) {
+    const marker = options.marker ?? shouldMark(filePath);
+    const finalContent = marker ? addMarker(filePath, content) : content;
+    recordGeneratedFile(context.program, filePath, marker);
+    await emitFile(context.program, {
+        path: filePath,
+        content: finalContent,
+    });
+}
+export async function emitGeneratedManifest(context) {
+    const entries = [...(generatedFilesByProgram.get(context.program)?.values() ?? [])]
+        .sort((left, right) => left.path.localeCompare(right.path));
+    const manifest = {
+        emitter: "typra-emitter",
+        version: 1,
+        generatedAt: new Date().toISOString(),
+        files: entries,
+    };
+    await emitFile(context.program, {
+        path: resolvePath(context.emitterOutputDir, ".typra-generated", "manifest.json"),
+        content: JSON.stringify(manifest, null, 2),
+    });
+}
+function recordGeneratedFile(program, filePath, marker) {
+    let entries = generatedFilesByProgram.get(program);
+    if (!entries) {
+        entries = new Map();
+        generatedFilesByProgram.set(program, entries);
+    }
+    entries.set(normalizePath(filePath), {
+        path: normalizePath(filePath),
+        marker,
+    });
+}
+function shouldMark(filePath) {
+    return !filePath.endsWith(".json");
+}
+function addMarker(filePath, content) {
+    const marker = markerFor(filePath);
+    return content.startsWith(marker) ? content : `${marker}\n${content}`;
+}
+function markerFor(filePath) {
+    if (filePath.endsWith(".md")) {
+        return "<!-- <auto-generated by typra-emitter> -->";
+    }
+    if (filePath.endsWith(".py") || filePath.endsWith(".yaml") || filePath.endsWith(".yml")) {
+        return "# <auto-generated by typra-emitter>";
+    }
+    return "// <auto-generated by typra-emitter>";
+}
+function normalizePath(filePath) {
+    const absolute = resolve(filePath);
+    const base = dirname(absolute);
+    return relative(base, absolute).startsWith("..")
+        ? absolute.replace(/\\/g, "/")
+        : filePath.replace(/\\/g, "/");
+}
+//# sourceMappingURL=generated-file.js.map

package/dist/src/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/src/cli.js

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+import { generate } from "./generate.js";
+import { parseArgs } from "util";
+const HELP = `
+typra-generate - Generate Typra runtime surfaces
+
+Usage:
+  npx typra-generate [options]
+
+Options:
+  -o, --output <dir>       Output directory (required)
+  -t, --targets <list>     Comma-separated list of targets (default: python,csharp,typescript,go)
+  -r, --root-object <name> Root object to generate from (default: Typra.FixtureRoot)
+  --omit <list>            Comma-separated list of models to omit
+  -n, --namespace <name>   Root namespace for generated code (default: Typra)
+  --no-tests               Skip generating test files
+  --no-format              Skip running formatters
+  -h, --help               Show this help message
+
+Examples:
+  # Generate all runtimes to ./generated
+  npx typra-generate -o ./generated
+
+  # Generate only Python and C# 
+  npx typra-generate -o ./lib -t python,csharp
+
+  # Generate a different root object
+  npx typra-generate -o ./lib -r Typra.Widget
+
+  # Omit specific models
+  npx typra-generate -o ./lib --omit LegacyWidget
+
+Targets:
+  python       Python dataclasses with YAML/JSON serialization
+  csharp       C# classes with System.Text.Json serialization
+  typescript   TypeScript interfaces with js-yaml serialization
+  go           Go structs with encoding/json and gopkg.in/yaml.v3
+  markdown     Markdown documentation
+`;
+async function main() {
+    const { values, positionals } = parseArgs({
+        options: {
+            output: { type: "string", short: "o" },
+            targets: { type: "string", short: "t" },
+            "root-object": { type: "string", short: "r" },
+            omit: { type: "string" },
+            namespace: { type: "string", short: "n" },
+            "no-tests": { type: "boolean", default: false },
+            "no-format": { type: "boolean", default: false },
+            help: { type: "boolean", short: "h" },
+        },
+        allowPositionals: true,
+    });
+    if (values.help) {
+        console.log(HELP);
+        process.exit(0);
+    }
+    // Output is required
+    const output = values.output || positionals[0];
+    if (!output) {
+        console.error("Error: Output directory is required. Use -o <dir> or --output <dir>\n");
+        console.log(HELP);
+        process.exit(1);
+    }
+    // Parse targets
+    const targetsString = values.targets || "python,csharp,typescript,go";
+    const targets = targetsString.split(",").map(t => t.trim().toLowerCase());
+    // Validate targets
+    const validTargets = ["python", "csharp", "typescript", "go", "markdown"];
+    for (const target of targets) {
+        if (!validTargets.includes(target)) {
+            console.error(`Error: Invalid target "${target}". Valid targets: ${validTargets.join(", ")}`);
+            process.exit(1);
+        }
+    }
+    // Parse omit list
+    const omit = values.omit ? values.omit.split(",").map(m => m.trim()) : [];
+    console.log(`\n🚀 Typra Generator\n`);
+    console.log(`  Output:      ${output}`);
+    console.log(`  Targets:     ${targets.join(", ")}`);
+    console.log(`  Root Object: ${values["root-object"] || "Typra.FixtureRoot"}`);
+    if (omit.length > 0) {
+        console.log(`  Omitting:    ${omit.join(", ")}`);
+    }
+    console.log();
+    const result = await generate({
+        output,
+        targets,
+        rootObject: values["root-object"] || "Typra.FixtureRoot",
+        omit,
+        namespace: values.namespace,
+        generateTests: !values["no-tests"],
+        format: !values["no-format"],
+    });
+    if (result.success) {
+        console.log(`✅ Successfully generated code for: ${result.targets.join(", ")}`);
+        console.log(`   Output directory: ${result.outputDir}\n`);
+        process.exit(0);
+    }
+    else {
+        console.error(`❌ Generation failed:`);
+        result.errors?.forEach(e => console.error(`   - ${e}`));
+        process.exit(1);
+    }
+}
+main().catch(error => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+});
+//# sourceMappingURL=cli.js.map

package/dist/src/decorators.d.ts

@@ -0,0 +1,56 @@
+import { type DecoratorContext, type Model, Program, Type, ModelProperty, ObjectValue } from "@typespec/compiler";
+export declare const appendStateValue: <T>(context: DecoratorContext, key: symbol, target: Type, value: T | T[]) => void;
+export declare const getStateValue: <T>(program: Program, key: symbol, target: Type) => T[];
+export declare const setStateScalar: <T>(context: DecoratorContext, key: symbol, target: Type, value: T) => void;
+export declare const getStateScalar: <T>(program: Program, key: symbol, target: Type) => T | undefined;
+export interface SampleOptions {
+    title?: string;
+    description?: string;
+}
+export interface SampleEntry {
+    sample: object;
+    title?: string;
+    description?: string;
+}
+export declare function $sample(context: DecoratorContext, target: ModelProperty, sample: ObjectValue | object, options?: SampleOptions): void;
+export declare function $abstract(context: DecoratorContext, target: Model): void;
+export declare function $coerce(context: DecoratorContext, target: Model, scalar: Type, expansion: ObjectValue | object, title?: string, description?: string, example?: string): void;
+export interface FactoryEntry {
+    /** Factory method name (e.g., "allow", "deny") */
+    name: string;
+    /** Field assignments — { fieldName: value } */
+    sets: Record<string, any>;
+    /** Optional parameters — { paramName: typeString } */
+    params: Record<string, string>;
+}
+export interface MethodEntry {
+    /** Method name (e.g., "text") */
+    name: string;
+    /** Return type as a string (e.g., "string") */
+    returns: string;
+    /** Human-readable description of what the method does */
+    description: string;
+    /** Method parameters as an ordered map of name → type string */
+    params: Record<string, string>;
+    /** Whether this method is optional (has a default implementation) */
+    optional: boolean;
+    /** Whether this method is synchronous (not wrapped in async/Promise/Task) */
+    sync: boolean;
+}
+export declare function $factory(context: DecoratorContext, target: Model, name: string, sets: object, params?: object): void;
+export declare function $method(context: DecoratorContext, target: Model, name: string, returns: string, description?: string, params?: object, optional?: boolean, sync?: boolean): void;
+export interface KnownAsEntry {
+    /** Provider identifier (e.g., "openai", "anthropic") */
+    provider: string;
+    /** Wire field name for that provider */
+    name: string;
+}
+export declare function $knownAs(context: DecoratorContext, target: ModelProperty, provider: string, name: string): void;
+export interface DefaultForEntry {
+    /** Provider identifier (e.g., "openai", "anthropic") */
+    provider: string;
+    /** Default value for that provider */
+    defaultValue: any;
+}
+export declare function $defaultFor(context: DecoratorContext, target: ModelProperty, provider: string, defaultValue: ObjectValue | object | string | number | boolean): void;
+export declare function $protocol(context: DecoratorContext, target: Model): void;

package/dist/src/decorators.js

@@ -0,0 +1,177 @@
+import { serializeValueAsJson } from "@typespec/compiler";
+import { StateKeys } from "./lib.js";
+export const appendStateValue = (context, key, target, value) => {
+    const state = context.program.stateMap(key).get(target) || [];
+    if (Array.isArray(value)) {
+        const newState = [...state, ...value];
+        context.program.stateMap(key).set(target, newState);
+    }
+    else {
+        const newState = [...state, value];
+        context.program.stateMap(key).set(target, newState);
+    }
+};
+export const getStateValue = (program, key, target) => {
+    return program.stateMap(key).get(target) || [];
+};
+export const setStateScalar = (context, key, target, value) => {
+    context.program.stateMap(key).set(target, value);
+};
+export const getStateScalar = (program, key, target) => {
+    const value = program.stateMap(key).get(target);
+    return value ? value : undefined;
+};
+export function $sample(context, target, sample, options) {
+    // With valueof unknown, TypeSpec passes a plain JavaScript object
+    // With unknown (no valueof), TypeSpec passes an ObjectValue with a type property
+    let s;
+    if (sample && typeof sample === 'object' && 'type' in sample && sample.type) {
+        // Old-style ObjectValue with type property
+        const sampleValue = sample;
+        const serialized = serializeValueAsJson(context.program, sampleValue, sampleValue.type);
+        if (!serialized) {
+            context.program.reportDiagnostic({
+                code: "typra-emitter-sample-serialization",
+                message: `Failed to serialize sample value.`,
+                severity: "error",
+                target: sampleValue,
+            });
+            return;
+        }
+        s = serialized;
+    }
+    else {
+        // New-style: plain JavaScript object from valueof unknown
+        s = sample;
+    }
+    if (!s.hasOwnProperty(target.name)) {
+        context.program.reportDiagnostic({
+            code: "typra-emitter-sample-name-mismatch",
+            message: `Sample object must have a property named '${target.name}' to match the target property.`,
+            severity: "error",
+            target: target,
+        });
+        return;
+    }
+    const entry = {
+        sample: s,
+        title: options?.title ?? "",
+        description: options?.description ?? "",
+    };
+    appendStateValue(context, StateKeys.samples, target, entry);
+}
+export function $abstract(context, target) {
+    setStateScalar(context, StateKeys.abstracts, target, true);
+}
+export function $coerce(context, target, scalar, expansion, title, description, example) {
+    if (scalar.kind !== "Scalar") {
+        context.program.reportDiagnostic({
+            code: "typra-emitter-coerce-scalar-type",
+            message: `Coerce decorator requires a scalar type for the scalar representation.`,
+            severity: "error",
+            target: scalar,
+        });
+        return;
+    }
+    // Handle both ObjectValue (old style) and plain object (valueof unknown)
+    let exp;
+    if (expansion && typeof expansion === 'object' && 'type' in expansion && expansion.type) {
+        const serialized = serializeValueAsJson(context.program, expansion, expansion.type);
+        if (!serialized) {
+            context.program.reportDiagnostic({
+                code: "typra-emitter-coerce-serialization",
+                message: `Failed to serialize expansion value.`,
+                severity: "error",
+                target: target,
+            });
+            return;
+        }
+        exp = serialized;
+    }
+    else {
+        exp = expansion;
+    }
+    // Handle string parameters that come as plain strings from valueof
+    const titleValue = typeof title === 'object' && title !== null && 'value' in title ? title.value : title;
+    const descValue = typeof description === 'object' && description !== null && 'value' in description ? description.value : description;
+    const exampleValue = typeof example === 'object' && example !== null && 'value' in example ? example.value : example;
+    const entry = {
+        scalar: scalar.name,
+        expansion: exp,
+        example: exampleValue,
+        title: titleValue ?? "",
+        description: descValue ?? "",
+    };
+    appendStateValue(context, StateKeys.coercions, target, entry);
+}
+function deserializeValue(value) {
+    if (value && typeof value === 'object' && 'type' in value && value.type) {
+        // ObjectValue from TypeSpec — shouldn't happen with valueof but handle defensively
+        return value;
+    }
+    return value;
+}
+export function $factory(context, target, name, sets, params) {
+    // Handle string values from valueof
+    const nameValue = typeof name === 'object' && name !== null && 'value' in name ? name.value : name;
+    const setsValue = deserializeValue(sets);
+    const paramsValue = params ? deserializeValue(params) : {};
+    const entry = {
+        name: nameValue,
+        sets: setsValue,
+        params: paramsValue,
+    };
+    appendStateValue(context, StateKeys.factories, target, entry);
+}
+export function $method(context, target, name, returns, description, params, optional, sync) {
+    const nameValue = typeof name === 'object' && name !== null && 'value' in name ? name.value : name;
+    const returnsValue = typeof returns === 'object' && returns !== null && 'value' in returns ? returns.value : returns;
+    const descValue = typeof description === 'object' && description !== null && 'value' in description ? description.value : description;
+    const paramsValue = params ? deserializeValue(params) : {};
+    const optionalValue = typeof optional === 'object' && optional !== null && 'value' in optional ? optional.value : optional ?? false;
+    const syncValue = typeof sync === 'object' && sync !== null && 'value' in sync ? sync.value : sync ?? false;
+    const entry = {
+        name: nameValue,
+        returns: returnsValue,
+        description: descValue ?? "",
+        params: paramsValue,
+        optional: optionalValue,
+        sync: syncValue,
+    };
+    appendStateValue(context, StateKeys.methods, target, entry);
+}
+export function $knownAs(context, target, provider, name) {
+    const providerValue = typeof provider === 'object' && provider !== null && 'value' in provider ? provider.value : provider;
+    const nameValue = typeof name === 'object' && name !== null && 'value' in name ? name.value : name;
+    const entry = { provider: providerValue, name: nameValue };
+    appendStateValue(context, StateKeys.knownAs, target, entry);
+}
+export function $defaultFor(context, target, provider, defaultValue) {
+    const providerValue = typeof provider === 'object' && provider !== null && 'value' in provider ? provider.value : provider;
+    let val;
+    if (defaultValue && typeof defaultValue === 'object' && 'type' in defaultValue && defaultValue.type) {
+        const serialized = serializeValueAsJson(context.program, defaultValue, defaultValue.type);
+        if (!serialized) {
+            context.program.reportDiagnostic({
+                code: "typra-emitter-defaultfor-serialization",
+                message: `Failed to serialize default value.`,
+                severity: "error",
+                target: target,
+            });
+            return;
+        }
+        val = serialized;
+    }
+    else {
+        val = defaultValue;
+    }
+    const entry = { provider: providerValue, defaultValue: val };
+    appendStateValue(context, StateKeys.defaultFor, target, entry);
+}
+// ============================================================================
+// Protocol decorator
+// ============================================================================
+export function $protocol(context, target) {
+    setStateScalar(context, StateKeys.protocols, target, true);
+}
+//# sourceMappingURL=decorators.js.map

package/dist/src/emitter.d.ts

@@ -0,0 +1,13 @@
+import { EmitContext } from "@typespec/compiler";
+import { TypeNode } from "./ir/ast.js";
+import { TypraEmitterOptions } from "./lib.js";
+export interface GeneratorOptions {
+    omitModels?: string[];
+    additionalModels?: TypeNode[];
+}
+/**
+ * Filter nodes based on omit-models option.
+ * Matches against model name (e.g., "AgentManifest") or fully qualified name (e.g., "Prompty.AgentManifest")
+ */
+export declare function filterNodes(nodes: TypeNode[], options?: GeneratorOptions): TypeNode[];
+export declare function $onEmit(context: EmitContext<TypraEmitterOptions>): Promise<void>;

package/dist/src/emitter.js

@@ -0,0 +1,137 @@
+import { resolvePath } from "@typespec/compiler";
+import { resolveModel, enumerateTypes } from "./ir/ast.js";
+import { generateMarkdown } from "./languages/markdown/driver.js";
+import { generatePython } from "./languages/python/driver.js";
+import { generateCsharp } from "./languages/csharp/driver.js";
+import { generateTypeScript } from "./languages/typescript/driver.js";
+import { generateGo } from "./languages/go/driver.js";
+import { generateRust } from "./languages/rust/driver.js";
+import { emitGeneratedFile, emitGeneratedManifest } from "./cleanup/generated-file.js";
+/**
+ * Filter nodes based on omit-models option.
+ * Matches against model name (e.g., "AgentManifest") or fully qualified name (e.g., "Prompty.AgentManifest")
+ */
+export function filterNodes(nodes, options) {
+    const omitModels = options?.omitModels || [];
+    // Include additional root models and their type trees
+    const additionalModels = options?.additionalModels || [];
+    if (additionalModels.length > 0) {
+        const existingNames = new Set(nodes.map(n => `${n.typeName.namespace}.${n.typeName.name}`));
+        const visited = new Set(existingNames);
+        for (const additionalModel of additionalModels) {
+            for (const subNode of enumerateTypes(additionalModel, new Set())) {
+                const fullName = `${subNode.typeName.namespace}.${subNode.typeName.name}`;
+                if (!visited.has(fullName)) {
+                    nodes.push(subNode);
+                    visited.add(fullName);
+                }
+            }
+        }
+    }
+    if (omitModels.length === 0)
+        return nodes;
+    return nodes.filter(node => {
+        const name = node.typeName.name;
+        const fullName = `${node.typeName.namespace}.${name}`;
+        return !omitModels.includes(name) && !omitModels.includes(fullName);
+    });
+}
+// Registry of available code generators
+const generators = {
+    markdown: generateMarkdown,
+    python: generatePython,
+    csharp: generateCsharp,
+    typescript: generateTypeScript,
+    go: generateGo,
+    rust: generateRust,
+};
+export async function $onEmit(context) {
+    const options = {
+        emitterOutputDir: context.emitterOutputDir,
+        ...context.options,
+    };
+    // resolving top level model
+    // this is the "Model" entry point for the emitter
+    const rootObject = options["root-object"];
+    const m = context.program.resolveTypeReference(rootObject);
+    if (!m[0] || m[0].kind !== "Model") {
+        throw new Error(`${rootObject} model not found or is not a model type.`);
+    }
+    const model = resolveModel(context.program, m[0], new Set(), options["root-namespace"] || "Typra", options["root-alias"] || "Typra");
+    if (options["root-alias"]) {
+        model.typeName = {
+            namespace: model.typeName.namespace,
+            name: options["root-alias"]
+        };
+    }
+    // Discover additional models not reachable from the root.
+    // If root-namespace is specified, resolve all models in that namespace
+    // so new types are automatically emitted without manual additional-roots.
+    const rootNamespace = options["root-namespace"] || "Typra";
+    const additionalModels = [];
+    const visited = new Set();
+    // Collect names already in the main model tree to avoid duplicates
+    const collectNames = (node) => {
+        visited.add(`${node.typeName.namespace}.${node.typeName.name}`);
+        for (const child of node.childTypes) {
+            collectNames(child);
+        }
+        for (const prop of node.properties) {
+            if (prop.type) {
+                collectNames(prop.type);
+                for (const child of prop.type.childTypes) {
+                    collectNames(child);
+                }
+            }
+        }
+    };
+    collectNames(model);
+    // Resolve the namespace and iterate all models
+    const nsRef = context.program.resolveTypeReference(rootNamespace);
+    if (nsRef[0] && nsRef[0].kind === "Namespace") {
+        const ns = nsRef[0];
+        for (const [, nsModel] of ns.models) {
+            const fullName = `${rootNamespace}.${nsModel.name}`;
+            if (visited.has(fullName))
+                continue;
+            // Skip uninstantiated template declarations (e.g., Named<T>, Id<T>)
+            if (nsModel.node && 'templateParameters' in nsModel.node &&
+                nsModel.node.templateParameters.length > 0 && !nsModel.templateMapper) {
+                continue;
+            }
+            const additionalNode = resolveModel(context.program, nsModel, new Set(), rootNamespace, options["root-alias"] || "Typra");
+            additionalModels.push(additionalNode);
+            visited.add(fullName);
+        }
+    }
+    // Also process any explicit additional-roots (for types outside the namespace)
+    const additionalRoots = options["additional-roots"] || [];
+    for (const rootName of additionalRoots) {
+        if (visited.has(rootName))
+            continue;
+        const ref = context.program.resolveTypeReference(rootName);
+        if (!ref[0] || ref[0].kind !== "Model") {
+            console.warn(`Warning: additional-root '${rootName}' not found or is not a model type. Skipping.`);
+            continue;
+        }
+        const additionalNode = resolveModel(context.program, ref[0], new Set(), rootNamespace, options["root-alias"] || "Typra");
+        additionalModels.push(additionalNode);
+        visited.add(rootName);
+    }
+    const targets = options["emit-targets"] || [];
+    const generatorOptions = {
+        omitModels: options["omit-models"] || [],
+        additionalModels: additionalModels,
+    };
+    // Dispatch to registered generators
+    for (const target of targets) {
+        const generatorName = target.type.toLowerCase().trim();
+        const generator = generators[generatorName];
+        if (generator) {
+            await generator(context, model, target, generatorOptions);
+        }
+    }
+    await emitGeneratedFile(context, resolvePath(context.emitterOutputDir, "json-ast", "model.json"), JSON.stringify(model.getSanitizedObject(), null, 2), { marker: false });
+    await emitGeneratedManifest(context);
+}
+//# sourceMappingURL=emitter.js.map

package/dist/src/generate.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Target language for code generation.
+ */
+export type TargetLanguage = "python" | "csharp" | "typescript" | "go" | "rust" | "markdown";
+/**
+ * Options for a specific target language.
+ */
+export interface TargetOptions {
+    /** Output directory for generated code */
+    outputDir: string;
+    /** Output directory for generated tests (optional) */
+    testDir?: string;
+    /** Override the namespace for generated code */
+    namespace?: string;
+    /** Run formatters on emitted files (default: true) */
+    format?: boolean;
+}
+/**
+ * Options for the generate function.
+ */
+export interface GenerateOptions {
+    /**
+     * Output directory for generated code.
+     * Each target will create a subdirectory (e.g., output/python, output/csharp)
+     */
+    output: string;
+    /**
+     * Target languages to generate code for.
+     * @default ["python", "csharp", "typescript", "go"]
+     */
+    targets?: TargetLanguage[] | Record<TargetLanguage, TargetOptions>;
+    /**
+     * Root object to start generation from.
+     * @default "Typra.FixtureRoot"
+     */
+    rootObject?: string;
+    /**
+     * List of model names to omit from generation.
+     * Can be simple names (e.g., "Widget") or fully qualified (e.g., "Typra.Widget")
+     */
+    omit?: string[];
+    /**
+     * Root namespace for the generated code.
+     * @default "Typra"
+     */
+    namespace?: string;
+    /**
+     * Alias for the root object in generated code.
+     */
+    rootAlias?: string;
+    /**
+     * Generate test files.
+     * @default true
+     */
+    generateTests?: boolean;
+    /**
+     * Run formatters on emitted files.
+     * @default true
+     */
+    format?: boolean;
+}
+/**
+ * Result of the generate function.
+ */
+export interface GenerateResult {
+    success: boolean;
+    outputDir: string;
+    targets: string[];
+    errors?: string[];
+}
+/**
+ * Generate Typra runtime surfaces.
+ *
+ * @example
+ * ```typescript
+ * import { generate } from '@typra/emitter/generate';
+ *
+ * await generate({
+ *   output: './generated',
+ *   targets: ['python', 'csharp'],
+ *   rootObject: 'Typra.Widget',
+ *   omit: ['LegacyWidget']
+ * });
+ * ```
+ */
+export declare function generate(options: GenerateOptions): Promise<GenerateResult>;