@typra/emitter 0.2.0

package/dist/src/languages/typescript/scaffolding.d.ts

@@ -0,0 +1,32 @@
+/**
+ * TypeScript scaffolding emitter — static/structural files.
+ *
+ * Replaces the Nunjucks templates:
+ *   - `context.ts.njk`       → emitTypeScriptContext()
+ *   - `index.ts.njk`         → emitTypeScriptIndex()
+ *   - `eslint.config.js.njk` → emitEslintConfig()
+ *
+ * These emit files whose content depends only on the type graph
+ * shape (not on the Declaration IR used for per-type files).
+ */
+import { TypeNode } from "../../ir/ast.js";
+/**
+ * Emit static TypeScript context classes (LoadContext, SaveContext).
+ */
+export declare function emitTypeScriptContext(): string;
+/**
+ * Emit the barrel export index.ts file.
+ *
+ * When types are organised into group subfolders, the root index.ts re-exports
+ * from each group's index.ts (e.g. `export * from "./connection/index"`).
+ */
+export declare function emitTypeScriptIndex(baseTypes: TypeNode[], _types: TypeNode[]): string;
+/**
+ * Emit a group-level index.ts barrel file.
+ * Lives at `model/{group}/index.ts` and re-exports all types in that group.
+ */
+export declare function emitTypeScriptGroupIndex(group: string, groupNodes: TypeNode[]): string;
+/**
+ * Emit the static ESLint configuration file.
+ */
+export declare function emitEslintConfig(): string;

package/dist/src/languages/typescript/scaffolding.js

@@ -0,0 +1,303 @@
+/**
+ * TypeScript scaffolding emitter — static/structural files.
+ *
+ * Replaces the Nunjucks templates:
+ *   - `context.ts.njk`       → emitTypeScriptContext()
+ *   - `index.ts.njk`         → emitTypeScriptIndex()
+ *   - `eslint.config.js.njk` → emitEslintConfig()
+ *
+ * These emit files whose content depends only on the type graph
+ * shape (not on the Declaration IR used for per-type files).
+ */
+import { toKebabCase } from "../../ir/utilities.js";
+// ============================================================================
+// Context classes (LoadContext, SaveContext)
+// ============================================================================
+/**
+ * Emit static TypeScript context classes (LoadContext, SaveContext).
+ */
+export function emitTypeScriptContext() {
+    return `// Copyright (c) Microsoft. All rights reserved.
+// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.
+
+import * as yaml from "yaml";
+
+/**
+ * Context for customizing the loading process of agent definitions.
+ *
+ * Provides hooks for pre-processing input data before parsing and
+ * post-processing output data after instantiation.
+ */
+export class LoadContext {
+  /**
+   * Optional callback to transform input data before parsing.
+   */
+  preProcess?: (data: Record<string, unknown>) => Record<string, unknown>;
+
+  /**
+   * Optional callback to transform the result after instantiation.
+   */
+  postProcess?: (result: unknown) => unknown;
+
+  constructor(init?: Partial<LoadContext>) {
+    if (init?.preProcess) {
+      this.preProcess = init.preProcess;
+    }
+    if (init?.postProcess) {
+      this.postProcess = init.postProcess;
+    }
+  }
+
+  /**
+   * Apply pre-processing to input data if a preProcess callback is set.
+   * @param data - The raw input dictionary to process.
+   * @returns The processed dictionary, or the original if no callback is set.
+   */
+  processInput(data: Record<string, unknown>): Record<string, unknown> {
+    if (this.preProcess) {
+      return this.preProcess(data);
+    }
+    return data;
+  }
+
+  /**
+   * Apply post-processing to the result if a postProcess callback is set.
+   * @param result - The instantiated object to process.
+   * @returns The processed result, or the original if no callback is set.
+   */
+  processOutput<T>(result: T): T {
+    if (this.postProcess) {
+      return this.postProcess(result) as T;
+    }
+    return result;
+  }
+}
+
+/**
+ * Context for customizing the serialization process of agent definitions.
+ *
+ * Provides hooks for pre-processing the object before serialization and
+ * post-processing the dictionary after serialization.
+ */
+export class SaveContext {
+  /**
+   * Optional callback to transform the object before serialization.
+   */
+  preSave?: (obj: unknown) => unknown;
+
+  /**
+   * Optional callback to transform the dictionary after serialization.
+   */
+  postSave?: (data: Record<string, unknown>) => Record<string, unknown>;
+
+  /**
+   * Output format for collections: "object" (name as key) or "array" (list of dicts).
+   * Defaults to "object".
+   */
+  collectionFormat: "object" | "array" = "object";
+
+  /**
+   * Use shorthand scalar representation when possible.
+   * Defaults to true.
+   */
+  useShorthand: boolean = true;
+
+  constructor(init?: Partial<SaveContext>) {
+    if (init?.preSave) {
+      this.preSave = init.preSave;
+    }
+    if (init?.postSave) {
+      this.postSave = init.postSave;
+    }
+    if (init?.collectionFormat) {
+      this.collectionFormat = init.collectionFormat;
+    }
+    if (init?.useShorthand !== undefined) {
+      this.useShorthand = init.useShorthand;
+    }
+  }
+
+  /**
+   * Apply pre-processing to the object if a preSave callback is set.
+   * @param obj - The object to process before serialization.
+   * @returns The processed object, or the original if no callback is set.
+   */
+  processObject<T>(obj: T): T {
+    if (this.preSave) {
+      return this.preSave(obj) as T;
+    }
+    return obj;
+  }
+
+  /**
+   * Apply post-processing to the dictionary if a postSave callback is set.
+   * @param data - The serialized dictionary to process.
+   * @returns The processed dictionary, or the original if no callback is set.
+   */
+  processDict(data: Record<string, unknown>): Record<string, unknown> {
+    if (this.postSave) {
+      return this.postSave(data);
+    }
+    return data;
+  }
+
+  /**
+   * Convert a dictionary to a YAML string.
+   * @param data - The dictionary to convert.
+   * @returns The YAML string representation.
+   */
+  toYaml(data: Record<string, unknown>): string {
+    return yaml.stringify(data, { indent: 2 });
+  }
+
+  /**
+   * Convert a dictionary to a JSON string.
+   * @param data - The dictionary to convert.
+   * @param indent - Number of spaces for indentation.
+   * @returns The JSON string representation.
+   */
+  toJson(data: Record<string, unknown>, indent: number = 2): string {
+    return JSON.stringify(data, null, indent);
+  }
+}
+`;
+}
+// ============================================================================
+// Barrel export index.ts
+// ============================================================================
+/**
+ * Emit the barrel export index.ts file.
+ *
+ * When types are organised into group subfolders, the root index.ts re-exports
+ * from each group's index.ts (e.g. `export * from "./connection/index"`).
+ */
+export function emitTypeScriptIndex(baseTypes, _types) {
+    const lines = [];
+    lines.push("// Copyright (c) Microsoft. All rights reserved.");
+    lines.push("// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.");
+    lines.push("");
+    lines.push('export { LoadContext, SaveContext } from "./context";');
+    // Group root types by their semantic group
+    const groupMap = new Map();
+    for (const type of baseTypes) {
+        const g = type.group || "";
+        if (!groupMap.has(g))
+            groupMap.set(g, []);
+        groupMap.get(g).push(type);
+    }
+    const sortedGroups = Array.from(groupMap.keys()).sort();
+    for (const group of sortedGroups) {
+        const groupTypes = groupMap.get(group);
+        if (!group) {
+            // Root-level types (no group) — emit inline re-exports
+            for (const type of groupTypes) {
+                const exportKeyword = type.isProtocol ? "export type" : "export";
+                if (type.childTypes.length > 0) {
+                    const exports = [type.typeName.name, ...type.childTypes.map((c) => c.typeName.name)];
+                    lines.push("");
+                    lines.push(`${exportKeyword} {`);
+                    for (const name of exports) {
+                        lines.push(`  ${name},`);
+                    }
+                    lines.push(`} from "./${toKebabCase(type.typeName.name)}";`);
+                }
+                else {
+                    lines.push(`${exportKeyword} { ${type.typeName.name} } from "./${toKebabCase(type.typeName.name)}";`);
+                }
+            }
+        }
+        else {
+            // Group subfolder — re-export from the group's index.ts
+            lines.push("");
+            for (const type of groupTypes) {
+                const exportKeyword = type.isProtocol ? "export type" : "export";
+                const allNames = [type.typeName.name, ...type.childTypes.map(c => c.typeName.name)];
+                if (allNames.length > 1) {
+                    lines.push(`${exportKeyword} { ${allNames.join(", ")} } from "./${group}/${toKebabCase(type.typeName.name)}";`);
+                }
+                else {
+                    lines.push(`${exportKeyword} { ${type.typeName.name} } from "./${group}/${toKebabCase(type.typeName.name)}";`);
+                }
+            }
+        }
+    }
+    lines.push("");
+    return lines.join("\n");
+}
+/**
+ * Emit a group-level index.ts barrel file.
+ * Lives at `model/{group}/index.ts` and re-exports all types in that group.
+ */
+export function emitTypeScriptGroupIndex(group, groupNodes) {
+    const lines = [];
+    lines.push("// Copyright (c) Microsoft. All rights reserved.");
+    lines.push("// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.");
+    lines.push("");
+    for (const type of groupNodes) {
+        const exportKeyword = type.isProtocol ? "export type" : "export";
+        const allNames = [type.typeName.name, ...type.childTypes.map(c => c.typeName.name)];
+        if (allNames.length > 1) {
+            lines.push(`${exportKeyword} {`);
+            for (const name of allNames) {
+                lines.push(`  ${name},`);
+            }
+            lines.push(`} from "./${toKebabCase(type.typeName.name)}";`);
+        }
+        else {
+            lines.push(`${exportKeyword} { ${type.typeName.name} } from "./${toKebabCase(type.typeName.name)}";`);
+        }
+    }
+    lines.push("");
+    return lines.join("\n");
+}
+// ============================================================================
+// ESLint configuration
+// ============================================================================
+/**
+ * Emit the static ESLint configuration file.
+ */
+export function emitEslintConfig() {
+    return `// ESLint configuration for auto-generated Typra TypeScript code
+// This file is auto-generated by the Typra emitter
+import js from "@eslint/js";
+import tseslint from "typescript-eslint";
+
+export default tseslint.config(
+  js.configs.recommended,
+  ...tseslint.configs.recommended,
+  {
+    files: ["src/**/*.ts"],
+    rules: {
+      // Allow unused vars prefixed with underscore
+      "@typescript-eslint/no-unused-vars": [
+        "error",
+        { argsIgnorePattern: "^_", varsIgnorePattern: "^_" },
+      ],
+      // Allow explicit any in generated code
+      "@typescript-eslint/no-explicit-any": "off",
+      // Allow non-null assertions in generated code
+      "@typescript-eslint/no-non-null-assertion": "off",
+      // Allow require() for dynamic YAML imports in generated code
+      "@typescript-eslint/no-require-imports": "off",
+      // Allow empty blocks in generated shorthand parsing patterns
+      "no-empty": "off",
+    },
+  },
+  {
+    files: ["tests/**/*.ts"],
+    rules: {
+      // Allow explicit any in test code
+      "@typescript-eslint/no-explicit-any": "off",
+      // Allow unused vars in generated tests
+      "@typescript-eslint/no-unused-vars": "off",
+      // Allow require() for dynamic YAML imports
+      "@typescript-eslint/no-require-imports": "off",
+    },
+  },
+  {
+    ignores: ["dist/**", "node_modules/**", "*.config.*"],
+  }
+);
+`;
+}
+//# sourceMappingURL=scaffolding.js.map

package/dist/src/languages/typescript/test-emitter.d.ts

@@ -0,0 +1,23 @@
+/**
+ * TypeScript test file emitter — BaseTestContext → vitest source code.
+ *
+ * Replaces the Nunjucks templates:
+ *   - `test.ts.njk`   → emitTypeScriptTest()
+ *   - `_macros.njk`    → factoryParamTestValue() (test-specific macro)
+ *
+ * The emitter produces vitest `describe`/`it` blocks for:
+ *   - Construction (default + partial)
+ *   - JSON serialization (load + round-trip per example)
+ *   - YAML serialization (load + round-trip per example)
+ *   - Alternate representations (scalar coercions)
+ *   - Factory methods
+ *   - Load/save (dictionary round-trip)
+ */
+import { BaseTestContext } from "../../ir/ast.js";
+/**
+ * Emit a vitest test file for a TypeNode.
+ */
+export declare function emitTypeScriptTest(ctx: BaseTestContext & {
+    importPath: string;
+    namespace: string;
+}): string;

package/dist/src/languages/typescript/test-emitter.js

@@ -0,0 +1,204 @@
+/**
+ * TypeScript test file emitter — BaseTestContext → vitest source code.
+ *
+ * Replaces the Nunjucks templates:
+ *   - `test.ts.njk`   → emitTypeScriptTest()
+ *   - `_macros.njk`    → factoryParamTestValue() (test-specific macro)
+ *
+ * The emitter produces vitest `describe`/`it` blocks for:
+ *   - Construction (default + partial)
+ *   - JSON serialization (load + round-trip per example)
+ *   - YAML serialization (load + round-trip per example)
+ *   - Alternate representations (scalar coercions)
+ *   - Factory methods
+ *   - Load/save (dictionary round-trip)
+ */
+// ============================================================================
+// Macro replacements
+// ============================================================================
+/**
+ * Map a factory parameter type string to a TypeScript test value literal.
+ * Replaces the `factoryParamTestValue` macro from `_macros.njk`.
+ */
+function factoryParamTestValue(typeStr) {
+    switch (typeStr) {
+        case "string":
+            return '"test"';
+        case "boolean":
+            return "true";
+        case "integer":
+        case "int32":
+        case "int64":
+            return "42";
+        case "float":
+        case "float64":
+        case "float32":
+            return "3.14";
+        case "unknown":
+        default:
+            return '"test"';
+    }
+}
+/**
+ * Render name in PascalCase (used by coercion test validation keys).
+ */
+function renderName(name) {
+    const pascal = name.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+    return pascal.charAt(0).toUpperCase() + pascal.slice(1);
+}
+// ============================================================================
+// Main entry point
+// ============================================================================
+/**
+ * Emit a vitest test file for a TypeNode.
+ */
+export function emitTypeScriptTest(ctx) {
+    const { node, isAbstract, examples, coercions, factories, importPath } = ctx;
+    const typeName = node.typeName.name;
+    const lines = [];
+    lines.push("// Copyright (c) Microsoft. All rights reserved.");
+    lines.push("// WARNING: This is an auto-generated file. DO NOT EDIT THIS FILE DIRECTLY.");
+    lines.push("");
+    lines.push(`import { ${typeName} } from "${importPath}";`);
+    lines.push("");
+    lines.push(`describe("${typeName}", () => {`);
+    lines.push(`  describe("construction", () => {`);
+    lines.push(`    it("should create a new instance with defaults", () => {`);
+    lines.push(`      const instance = new ${typeName}();`);
+    lines.push(`      expect(instance).toBeDefined();`);
+    lines.push(`    });`);
+    lines.push("");
+    lines.push(`    it("should create a new instance with partial initialization", () => {`);
+    lines.push(`      const instance = new ${typeName}({});`);
+    lines.push(`      expect(instance).toBeDefined();`);
+    lines.push(`    });`);
+    lines.push(`  });`);
+    // JSON serialization
+    if (examples.length > 0) {
+        lines.push("");
+        lines.push(`  describe("JSON serialization", () => {`);
+        for (let i = 0; i < examples.length; i++) {
+            const example = examples[i];
+            const exampleNum = i + 1;
+            lines.push(`    it("should load from JSON - example ${exampleNum}", () => {`);
+            lines.push("      const json = `" + example.json.join("\\n") + "`;");
+            lines.push(`      const instance = ${typeName}.fromJson(json);`);
+            lines.push(`      expect(instance).toBeDefined();`);
+            for (const val of example.validations) {
+                lines.push(`      expect(instance.${val.key}).toEqual(${val.delimiter}${val.value}${val.delimiter});`);
+            }
+            lines.push(`    });`);
+            lines.push("");
+            lines.push(`    it("should round-trip JSON - example ${exampleNum}", () => {`);
+            lines.push("      const json = `" + example.json.join("\\n") + "`;");
+            lines.push(`      const instance = ${typeName}.fromJson(json);`);
+            lines.push(`      const output = instance.toJson();`);
+            lines.push(`      const reloaded = ${typeName}.fromJson(output);`);
+            for (const val of example.validations) {
+                lines.push(`      expect(reloaded.${val.key}).toEqual(instance.${val.key});`);
+            }
+            lines.push(`    });`);
+        }
+        lines.push(`  });`);
+        // YAML serialization
+        lines.push("");
+        lines.push(`  describe("YAML serialization", () => {`);
+        for (let i = 0; i < examples.length; i++) {
+            const example = examples[i];
+            const exampleNum = i + 1;
+            lines.push(`    it("should load from YAML - example ${exampleNum}", () => {`);
+            lines.push("      const yaml = `" + example.yaml.join("\\n") + "`;");
+            lines.push(`      const instance = ${typeName}.fromYaml(yaml);`);
+            lines.push(`      expect(instance).toBeDefined();`);
+            for (const val of example.validations) {
+                lines.push(`      expect(instance.${val.key}).toEqual(${val.delimiter}${val.value}${val.delimiter});`);
+            }
+            lines.push(`    });`);
+            lines.push("");
+            lines.push(`    it("should round-trip YAML - example ${exampleNum}", () => {`);
+            lines.push("      const yaml = `" + example.yaml.join("\\n") + "`;");
+            lines.push(`      const instance = ${typeName}.fromYaml(yaml);`);
+            lines.push(`      const output = instance.toYaml();`);
+            lines.push(`      const reloaded = ${typeName}.fromYaml(output);`);
+            for (const val of example.validations) {
+                lines.push(`      expect(reloaded.${val.key}).toEqual(instance.${val.key});`);
+            }
+            lines.push(`    });`);
+        }
+        lines.push(`  });`);
+    }
+    // Alternate representations (coercions)
+    if (coercions.length > 0) {
+        lines.push("");
+        lines.push(`  describe("alternate representations", () => {`);
+        for (const alt of coercions) {
+            lines.push(`    it("should handle ${alt.title} alternate representation", () => {`);
+            lines.push(`      const value = ${alt.value};`);
+            lines.push(`      const json = JSON.stringify(value);`);
+            lines.push(`      const instance = ${typeName}.fromJson(json);`);
+            lines.push(`      expect(instance).toBeDefined();`);
+            for (const val of alt.validations) {
+                const coercionKey = renderName(val.key).toLowerCase().replace(/\./g, "");
+                lines.push(`      expect(instance.${coercionKey}).toEqual(${val.delimiter}${val.value}${val.delimiter});`);
+            }
+            lines.push(`    });`);
+        }
+        lines.push(`  });`);
+    }
+    // Factory methods
+    if (factories.length > 0) {
+        lines.push("");
+        lines.push(`  describe("factory methods", () => {`);
+        for (const factory of factories) {
+            const paramValues = Object.values(factory.params)
+                .map((pType) => factoryParamTestValue(pType))
+                .join(", ");
+            lines.push(`    it("should create instance via ${factory.name}() factory", () => {`);
+            lines.push(`      const instance = ${typeName}.${factory.name}(${paramValues});`);
+            lines.push(`      expect(instance).toBeDefined();`);
+            lines.push(`      expect(instance).toBeInstanceOf(${typeName});`);
+            for (const [propName, value] of Object.entries(factory.sets)) {
+                if (value === true) {
+                    lines.push(`      expect(instance.${propName}).toBe(true);`);
+                }
+                else if (value === false) {
+                    lines.push(`      expect(instance.${propName}).toBe(false);`);
+                }
+                else if (typeof value === "number") {
+                    lines.push(`      expect(instance.${propName}).toBe(${value});`);
+                }
+                else if (typeof value === "string") {
+                    lines.push(`      expect(instance.${propName}).toBe("${value}");`);
+                }
+            }
+            lines.push(`    });`);
+        }
+        lines.push(`  });`);
+    }
+    // Load and save
+    lines.push("");
+    if (!(isAbstract && node.isAbstract)) {
+        lines.push(`  describe("load and save", () => {`);
+        if (!isAbstract) {
+            lines.push(`    it("should load from dictionary", () => {`);
+            lines.push(`      const data: Record<string, unknown> = {};`);
+            lines.push(`      const instance = ${typeName}.load(data);`);
+            lines.push(`      expect(instance).toBeDefined();`);
+            lines.push(`    });`);
+        }
+        lines.push("");
+        if (!node.isAbstract) {
+            lines.push(`    it("should save to dictionary", () => {`);
+            lines.push(`      const instance = new ${typeName}();`);
+            lines.push(`      const data = instance.save();`);
+            lines.push(`      expect(data).toBeDefined();`);
+            lines.push(`      expect(typeof data).toBe("object");`);
+            lines.push(`    });`);
+        }
+        lines.push(`  });`);
+    }
+    lines.push("});");
+    lines.push("");
+    return lines.join("\n");
+}
+//# sourceMappingURL=test-emitter.js.map

package/dist/src/languages/typescript/visitor.d.ts

@@ -0,0 +1,14 @@
+/**
+ * TypeScript expression visitor — Expr IR → TypeScript source fragments.
+ */
+import { Expr, TypeRegistry } from "../../ir/expansion.js";
+import { ExprVisitor } from "../../ir/visitor.js";
+export declare class TypeScriptExprVisitor implements ExprVisitor {
+    registry?: TypeRegistry;
+    constructor(registry?: TypeRegistry);
+    visitExpr(expr: Expr): string;
+    private visitConstruct;
+    private visitVariant;
+    private visitArray;
+    private escapeString;
+}

package/dist/src/languages/typescript/visitor.js

@@ -0,0 +1,64 @@
+/**
+ * TypeScript expression visitor — Expr IR → TypeScript source fragments.
+ */
+import { assertNever } from "../../ir/visitor.js";
+export class TypeScriptExprVisitor {
+    registry;
+    constructor(registry) {
+        this.registry = registry;
+    }
+    visitExpr(expr) {
+        switch (expr.kind) {
+            case "string":
+                return `"${this.escapeString(expr.value)}"`;
+            case "number":
+                return String(expr.value);
+            case "boolean":
+                return expr.value ? "true" : "false";
+            case "null":
+                return "undefined";
+            case "param":
+                return expr.name;
+            case "construct":
+                return this.visitConstruct(expr);
+            case "variant":
+                return this.visitVariant(expr);
+            case "array":
+                return this.visitArray(expr);
+            case "dict":
+                return `{ ${expr.entries.map(e => `${e.key}: ${this.visitExpr(e.value)}`).join(", ")} }`;
+            case "field_read":
+                return `${expr.objectName}.${expr.fieldName}`;
+            default:
+                return assertNever(expr);
+        }
+    }
+    visitConstruct(expr) {
+        const typeName = expr.typeName.name;
+        if (expr.fields.length === 0) {
+            return `new ${typeName}({})`;
+        }
+        const fields = expr.fields.map(f => `${f.propertyName}: ${this.visitExpr(f.value)}`).join(", ");
+        return `new ${typeName}({ ${fields} })`;
+    }
+    visitVariant(expr) {
+        // In TypeScript, polymorphic children are full classes — construct the variant type directly
+        const variantName = expr.variantTypeName.name;
+        if (expr.fields.length === 0) {
+            return `new ${variantName}({})`;
+        }
+        const fields = expr.fields.map(f => `${f.propertyName}: ${this.visitExpr(f.value)}`).join(", ");
+        return `new ${variantName}({ ${fields} })`;
+    }
+    visitArray(expr) {
+        if (expr.items.length === 0) {
+            return "[]";
+        }
+        const items = expr.items.map(i => this.visitExpr(i)).join(", ");
+        return `[${items}]`;
+    }
+    escapeString(s) {
+        return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+    }
+}
+//# sourceMappingURL=visitor.js.map

package/dist/src/lib.d.ts

@@ -0,0 +1,33 @@
+export interface EmitTarget {
+    "type": string;
+    "output-dir"?: string;
+    "test-dir"?: string;
+    "alias"?: {
+        [key: string]: any;
+    };
+    "format"?: boolean;
+    "namespace"?: string;
+    "import-path"?: string;
+}
+export interface TypraEmitterOptions {
+    "root-object": string;
+    "emit-targets"?: EmitTarget[];
+    "root-namespace"?: string;
+    "root-alias"?: string;
+    "omit-models"?: string[];
+    "schema-output-dir"?: string;
+    "additional-roots"?: string[];
+}
+export declare const $lib: import("@typespec/compiler").TypeSpecLibrary<{
+    [code: string]: import("@typespec/compiler").DiagnosticMessages;
+}, TypraEmitterOptions, "samples" | "coercions" | "abstracts" | "factories" | "methods" | "knownAs" | "defaultFor" | "protocols">;
+export declare const reportDiagnostic: <C extends string | number, M extends keyof {
+    [code: string]: import("@typespec/compiler").DiagnosticMessages;
+}[C]>(program: import("@typespec/compiler").Program, diag: import("@typespec/compiler").DiagnosticReport<{
+    [code: string]: import("@typespec/compiler").DiagnosticMessages;
+}, C, M>) => void, createDiagnostic: <C extends string | number, M extends keyof {
+    [code: string]: import("@typespec/compiler").DiagnosticMessages;
+}[C]>(diag: import("@typespec/compiler").DiagnosticReport<{
+    [code: string]: import("@typespec/compiler").DiagnosticMessages;
+}, C, M>) => import("@typespec/compiler").Diagnostic;
+export declare const StateKeys: Record<"samples" | "coercions" | "abstracts" | "factories" | "methods" | "knownAs" | "defaultFor" | "protocols", symbol>;