tjs-lang 0.6.19 → 0.6.26

package/dist/scripts/build-demo.d.ts

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

package/dist/scripts/build.d.ts

@@ -1,11 +0,0 @@
-#!/usr/bin/env bun
-/**
- * Build script for TJS bundles
- *
- * Produces separate bundles for different use cases:
- * - tjs-vm.js        - VM runtime only (universal endpoint)
- * - tjs-batteries.js - LLM, vector, store ops (optional runtime)
- * - tjs-transpiler.js - TJS/AJS transpiler (no TS compiler)
- * - tjs-full.js      - Everything including fromTS + TS compiler
- */
-export {};

package/dist/scripts/seed-blog-rules.d.ts

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

package/dist/scripts/seed-stored-function.d.ts

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

package/dist/src/atoms/batteries.d.ts

@@ -1,4 +0,0 @@
-/**
- * @deprecated Import from '../vm/atoms/batteries' instead
- */
-export * from '../vm/atoms/batteries';

package/dist/src/atoms/browser.d.ts

@@ -1,4 +0,0 @@
-/**
- * @deprecated Import from '../vm/atoms/browser' instead
- */
-export * from '../vm/atoms/browser';

package/dist/src/atoms/index.d.ts

@@ -1,4 +0,0 @@
-/**
- * @deprecated Import from '../vm/atoms' instead
- */
-export * from '../vm/atoms';

package/dist/src/batteries/audit.d.ts

@@ -1,9 +0,0 @@
-export interface ModelAudit {
-    id: string;
-    type: 'LLM' | 'Embedding' | 'Unknown';
-    structuredOutput: boolean;
-    vision: boolean;
-    dimension?: number;
-    status: string;
-}
-export declare function auditModels(baseUrl: string): Promise<ModelAudit[]>;

package/dist/src/batteries/index.d.ts

@@ -1,28 +0,0 @@
-import { getStoreCapability as getStoreCapabilityDefault } from './store';
-import { getLLMCapability } from './llm';
-import { LocalModels } from './models';
-export declare function getBatteries(): Promise<{
-    vector: {
-        embed: (text: string) => Promise<number[]>;
-    } | undefined;
-    store: import("./store").StoreCapability;
-    llmBattery: import("./llm").LLMCapability | null;
-    models: LocalModels | null;
-}>;
-export declare function getStandardCapabilities(): Promise<{
-    vector: {
-        embed: (text: string) => Promise<number[]>;
-    } | undefined;
-    store: import("./store").StoreCapability;
-    llmBattery: import("./llm").LLMCapability | null;
-    models: LocalModels | null;
-}>;
-export { LocalModels, getLLMCapability, getStoreCapabilityDefault };
-export declare const batteries: {
-    store: import("./store").StoreCapability;
-    llmBattery: ReturnType<typeof getLLMCapability> | null;
-    vector: {
-        embed: (text: string) => Promise<number[]>;
-    } | undefined;
-    models: LocalModels | null;
-};

package/dist/src/batteries/llm.d.ts

@@ -1,18 +0,0 @@
-import { LocalModels } from './models';
-/**
- * LLM Capability Battery
- * Bridges to local LM Studio instance via HTTP.
- */
-/**
- * User content can be a simple string or multimodal with images.
- * Images should be URLs or data URIs (data:image/...;base64,...)
- */
-export type UserContent = string | {
-    text: string;
-    images?: string[];
-};
-export interface LLMCapability {
-    predict(system: string, user: UserContent, tools?: any[], responseFormat?: any): Promise<any>;
-    embed(text: string): Promise<number[]>;
-}
-export declare function getLLMCapability(models: LocalModels, baseUrl?: string): LLMCapability;

package/dist/src/batteries/models.d.ts

@@ -1,19 +0,0 @@
-import { type ModelAudit } from './audit';
-export declare class LocalModels {
-    private baseUrl;
-    private models;
-    private defaultLLM;
-    private defaultEmbedding;
-    private defaultStructuredLLM;
-    constructor(baseUrl?: string);
-    audit(): Promise<void>;
-    private selectDefaults;
-    getModels(): ModelAudit[];
-    private _setDefaultModel;
-    setDefaultLLM(modelId: string): void;
-    setDefaultEmbedding(modelId: string): void;
-    setDefaultStructuredLLM(modelId: string): void;
-    getLLM(): ModelAudit;
-    getEmbedding(): ModelAudit;
-    getStructuredLLM(): ModelAudit;
-}

package/dist/src/batteries/store.d.ts

@@ -1,13 +0,0 @@
-/**
- * Store Capability Battery
- * Provides Key-Value storage and lightweight in-memory Vector Search.
- */
-export interface StoreCapability {
-    get(key: string): Promise<any>;
-    set(key: string, val: any): Promise<void>;
-    createCollection(name: string, schema?: any, dimension?: number): Promise<void>;
-    vectorAdd(collection: string, doc: any): Promise<void>;
-    vectorSearch(collection: string, vector: number[], k?: number): Promise<any[]>;
-}
-export declare function cosineSimilarity(vecA: number[], vecB: number[]): number;
-export declare function getStoreCapability(): StoreCapability;

package/dist/src/builder.d.ts

@@ -1,127 +0,0 @@
-import { coreAtoms, type Atom, type OpCode } from './runtime';
-/**
- * VarMapping maps condition variable names to state paths.
- * Keys are variable names used in the condition string,
- * values are state paths (e.g., { count: 'counter.value' }).
- */
-type VarMapping = Record<string, string>;
-/**
- * ItemsRef is a reference to an array in state (string path)
- * or a literal array value for iteration atoms.
- */
-type ItemsRef = string | unknown[];
-export interface BaseNode {
-    op: OpCode;
-    [key: string]: any;
-}
-export interface SeqNode extends BaseNode {
-    op: 'seq';
-    steps: BaseNode[];
-}
-export interface ArgRef {
-    $kind: 'arg';
-    path: string;
-}
-type AtomInput<T> = T extends Atom<infer I, any> ? I : never;
-type BuilderMethods<M extends Record<string, Atom<any, any>>> = {
-    [K in keyof M as M[K]['op']]: (input: AtomInput<M[K]>) => BuilderType<M>;
-};
-interface ControlFlow<M extends Record<string, Atom<any, any>>> {
-    varsImport(keys: string[] | Record<string, string>): BuilderType<M>;
-    varsExport(keys: string[] | Record<string, string>): BuilderType<M>;
-    /**
-     * Conditional branch. Condition is a JS-like expression string.
-     * @param condition - Expression like "count > 0 && active"
-     * @param vars - Map condition vars to state paths: { count: 'state.count' }
-     * @param thenBranch - Steps to run if condition is true
-     * @param elseBranch - Optional steps if condition is false
-     */
-    if(condition: string, vars: VarMapping, thenBranch: (b: BuilderType<M>) => BuilderType<M>, elseBranch?: (b: BuilderType<M>) => BuilderType<M>): BuilderType<M>;
-    /**
-     * Loop while condition is true.
-     * @param condition - Expression like "count < 10"
-     * @param vars - Map condition vars to state paths
-     * @param body - Steps to run each iteration
-     */
-    while(condition: string, vars: VarMapping, body: (b: BuilderType<M>) => BuilderType<M>): BuilderType<M>;
-    scope(steps: (b: BuilderType<M>) => BuilderType<M>): BuilderType<M>;
-    /**
-     * Transform each item in array.
-     * @param items - State path to array or literal array
-     * @param as - Variable name for current item in scope
-     * @param steps - Transform steps (result is new item value)
-     */
-    map(items: ItemsRef, as: string, steps: (b: BuilderType<M>) => BuilderType<M>): BuilderType<M>;
-    /**
-     * Filter array to items matching condition.
-     * @param items - State path to array or literal array
-     * @param as - Variable name for current item
-     * @param condition - Filter expression using 'as' variable
-     * @param vars - Additional var mappings (optional)
-     */
-    filter(items: ItemsRef, as: string, condition: string, vars?: VarMapping): BuilderType<M>;
-    /**
-     * Find first item matching condition.
-     * @param items - State path to array or literal array
-     * @param as - Variable name for current item
-     * @param condition - Search expression
-     * @param vars - Additional var mappings (optional)
-     */
-    find(items: ItemsRef, as: string, condition: string, vars?: VarMapping): BuilderType<M>;
-    /**
-     * Reduce array to single value.
-     * @param items - State path to array or literal array
-     * @param as - Variable name for current item
-     * @param accumulator - Variable name for running result
-     * @param initial - Initial accumulator value
-     * @param steps - Reduction steps (result becomes new accumulator)
-     */
-    reduce<T>(items: ItemsRef, as: string, accumulator: string, initial: T, steps: (b: BuilderType<M>) => BuilderType<M>): BuilderType<M>;
-    memoize(steps: (b: BuilderType<M>) => BuilderType<M>, key?: string): BuilderType<M>;
-    cache(steps: (b: BuilderType<M>) => BuilderType<M>, key?: string, ttlMs?: number): BuilderType<M>;
-    try(branches: {
-        try: (b: BuilderType<M>) => BuilderType<M>;
-        catch?: (b: BuilderType<M>) => BuilderType<M>;
-    }): BuilderType<M>;
-}
-export declare class TypedBuilder<M extends Record<string, Atom<any, any>>> {
-    steps: BaseNode[];
-    private atoms;
-    private proxy;
-    constructor(atoms: M);
-    private add;
-    as(variableName: string): BuilderType<M>;
-    step(node: BaseNode): BuilderType<M>;
-    return(schema: any): BuilderType<M>;
-    toJSON(): SeqNode;
-    varsImport(keys: string[] | Record<string, string>): BuilderType<M>;
-    varsExport(keys: string[] | Record<string, string>): BuilderType<M>;
-    if(condition: string, vars: VarMapping, thenBranch: (b: BuilderType<M>) => BuilderType<M>, elseBranch?: (b: BuilderType<M>) => BuilderType<M>): BuilderType<M>;
-    while(condition: string, vars: VarMapping, body: (b: BuilderType<M>) => BuilderType<M>): BuilderType<M>;
-    scope(steps: (b: BuilderType<M>) => BuilderType<M>): BuilderType<M>;
-    map(items: ItemsRef, as: string, steps: (b: BuilderType<M>) => BuilderType<M>): BuilderType<M>;
-    filter(items: ItemsRef, as: string, condition: string, vars?: VarMapping): BuilderType<M>;
-    find(items: ItemsRef, as: string, condition: string, vars?: VarMapping): BuilderType<M>;
-    reduce<T>(items: ItemsRef, as: string, accumulator: string, initial: T, steps: (b: BuilderType<M>) => BuilderType<M>): BuilderType<M>;
-    memoize(steps: (b: BuilderType<M>) => BuilderType<M>, key?: string): BuilderType<M>;
-    cache(steps: (b: BuilderType<M>) => BuilderType<M>, key?: string, ttlMs?: number): BuilderType<M>;
-    try(branches: {
-        try: (b: BuilderType<M>) => BuilderType<M>;
-        catch?: (b: BuilderType<M>) => BuilderType<M>;
-    }): BuilderType<M>;
-}
-export type BuilderType<M extends Record<string, Atom<any, any>>> = TypedBuilder<M> & BuilderMethods<M> & ControlFlow<M>;
-export declare const Agent: {
-    take(_schema?: any): BuilderType<typeof coreAtoms>;
-    custom<M extends Record<string, Atom<any, any>>>(atoms: M): BuilderType<M>;
-    args(path: string): ArgRef;
-    val(path: string): string;
-};
-/** @deprecated Use `Agent` instead */
-export declare const A99: {
-    take(_schema?: any): BuilderType<typeof coreAtoms>;
-    custom<M extends Record<string, Atom<any, any>>>(atoms: M): BuilderType<M>;
-    args(path: string): ArgRef;
-    val(path: string): string;
-};
-export {};

package/dist/src/bun-plugin/tjs-plugin.d.ts

@@ -1,12 +0,0 @@
-/**
- * Bun plugin for native .tjs file support
- *
- * Enables `bun run file.tjs` to work directly.
- *
- * Register in bunfig.toml:
- *   preload = ["./src/bun-plugin/tjs-plugin.ts"]
- *
- * Or programmatically:
- *   import "./src/bun-plugin/tjs-plugin"
- */
-export {};

package/dist/src/cli/commands/check.d.ts

@@ -1,4 +0,0 @@
-/**
- * tjs check - Parse and type check a TJS file
- */
-export declare function check(file: string): Promise<void>;

package/dist/src/cli/commands/convert.d.ts

@@ -1,20 +0,0 @@
-/**
- * tjs convert - Convert TypeScript files to JavaScript (via TJS)
- *
- * By default, converts TS → JS with runtime type checks and introspection.
- * Use --emit-tjs to output the intermediate TJS format instead.
- *
- * Usage:
- *   tjs convert <file.ts>              Convert single file, output to stdout
- *   tjs convert <file.ts> -o <out.js>  Convert single file to output file
- *   tjs convert <dir> -o <outdir>      Convert all .ts files in directory
- *   tjs convert --emit-tjs <file.ts>   Output intermediate TJS instead of JS
- */
-export interface ConvertOptions {
-    output?: string;
-    recursive?: boolean;
-    verbose?: boolean;
-    /** Output intermediate TJS instead of final JS */
-    emitTJS?: boolean;
-}
-export declare function convert(input: string, options?: ConvertOptions): Promise<void>;

package/dist/src/cli/commands/emit.d.ts

@@ -1,34 +0,0 @@
-/**
- * tjs emit - Output transpiled JavaScript
- *
- * Usage:
- *   tjs emit <file.tjs>                 Emit single file to stdout
- *   tjs emit <file.tjs> -o <out.js>     Emit single file to output
- *   tjs emit <dir> -o <outdir>          Emit all .tjs files in directory
- *   tjs emit --unsafe <file.tjs>        Emit without __tjs metadata (production)
- *   tjs emit --dts <file.tjs>           Also generate .d.ts declaration file
- *   tjs emit --no-docs <file.tjs>       Suppress documentation generation
- *   tjs emit --docs-dir <dir>           Output docs to separate directory
- *   tjs emit --jfdi <file.tjs>          Emit even if tests fail (just fucking do it)
- */
-export interface EmitOptions {
-    /** Include source locations in __tjs metadata */
-    debug?: boolean;
-    /** Output path (file or directory) */
-    output?: string;
-    /** Strip __tjs metadata for production builds */
-    unsafe?: boolean;
-    /** Recursive directory processing */
-    recursive?: boolean;
-    /** Verbose output */
-    verbose?: boolean;
-    /** Suppress documentation generation */
-    noDocs?: boolean;
-    /** Output docs to separate directory (default: alongside JS) */
-    docsDir?: string;
-    /** Emit even if tests fail (just fucking do it) */
-    jfdi?: boolean;
-    /** Generate .d.ts TypeScript declaration file alongside JS */
-    dts?: boolean;
-}
-export declare function emit(input: string, options?: EmitOptions): Promise<void>;

package/dist/src/cli/commands/run.d.ts

@@ -1,6 +0,0 @@
-/**
- * tjs run - Transpile and execute a TJS file
- *
- * Executes the entire file as a script, with full TJS runtime support.
- */
-export declare function run(file: string): Promise<void>;

package/dist/src/cli/commands/test.d.ts

@@ -1,21 +0,0 @@
-/**
- * tjs test - Run TJS test files
- *
- * Usage:
- *   tjs test                     Run all .test.tjs files
- *   tjs test <file>              Run specific test file
- *   tjs test <dir>               Run all .test.tjs files in directory
- *   tjs test -t <pattern>        Run tests matching pattern
- *
- * This command wraps `bun test` with the TJS plugin preloaded,
- * and generates temporary wrapper files for .test.tjs files since
- * Bun's test runner only recognizes standard extensions.
- */
-export interface TestOptions {
-    pattern?: string;
-    timeout?: number;
-    watch?: boolean;
-    coverage?: boolean;
-    bail?: number;
-}
-export declare function test(input?: string, options?: TestOptions): Promise<void>;

package/dist/src/cli/commands/types.d.ts

@@ -1,4 +0,0 @@
-/**
- * tjs types - Output type metadata as JSON
- */
-export declare function types(file: string): Promise<void>;

package/dist/src/cli/create-app.d.ts

@@ -1,9 +0,0 @@
-#!/usr/bin/env bun
-/**
- * create-tjs-app - Scaffold a new TJS project
- *
- * Usage:
- *   bun create tjs-app my-app
- *   bunx create-tjs-app my-app
- */
-export {};

package/dist/src/cli/playground.d.ts

@@ -1,9 +0,0 @@
-#!/usr/bin/env bun
-/**
- * tjs-playground - Serve the TJS playground locally
- *
- * Usage:
- *   tjs-playground [--port 8699]
- *   bunx tjs-playground
- */
-export {};

package/dist/src/cli/tjs.d.ts

@@ -1,15 +0,0 @@
-#!/usr/bin/env bun
-/**
- * TJS CLI - Command line interface for Typed JavaScript
- *
- * Commands:
- *   tjs check <file>   - Parse and type check, report errors
- *   tjs run <file>     - Transpile to JS and execute
- *   tjs types <file>   - Output type metadata as JSON
- *   tjs emit <file>    - Output transpiled JavaScript
- *
- * Options:
- *   --help, -h         - Show help
- *   --version, -v      - Show version
- */
-export {};

package/dist/src/cli/tjsx.d.ts

@@ -1,16 +0,0 @@
-#!/usr/bin/env bun
-/**
- * tjsx - Execute TJS files instantly
- *
- * Like `bun run` but for TJS files. Transpiles and executes in one step.
- *
- * Usage:
- *   tjsx script.tjs [args...]
- *   tjsx --help
- *
- * Examples:
- *   tjsx hello.tjs
- *   tjsx server.tjs --port 3000
- *   echo '{"name": "World"}' | tjsx greet.tjs
- */
-export {};

package/dist/src/index.d.ts

@@ -1,11 +0,0 @@
-export * from './lang';
-export * from './vm/runtime';
-export * from './vm/vm';
-export * from './vm/atoms';
-export * from './builder';
-export * from './batteries';
-export * from './types';
-export * from './transpiler';
-export * from './runtime';
-export * from './vm';
-export * from './atoms';

package/dist/src/inference.types.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/lang/core.d.ts

@@ -1,56 +0,0 @@
-/**
- * TJS Core - Essential transpiler functions without TypeScript dependency
- *
- * This module provides the core AJS transpilation functions.
- * Import from here (not ./index) to avoid pulling in the TS compiler.
- */
-import type { SeqNode } from '../builder';
-import type { TranspileOptions, TranspileResult, FunctionSignature } from './types';
-import { type TJSTranspileResult, type TJSTranspileOptions } from './emitters/js';
-export * from './types';
-export { parse, preprocess, extractTDoc, validateSingleFunction, } from './parser';
-export { transformFunction } from './emitters/ast';
-/**
- * Transpile JavaScript source code to Agent99 AST
- */
-export declare function transpile(source: string, options?: TranspileOptions): TranspileResult;
-/**
- * Transpile AsyncJS source and return just the AST
- */
-export declare function ajs(strings: TemplateStringsArray, ...values: any[]): SeqNode;
-export declare function ajs(source: string): SeqNode;
-/**
- * Create a function with attached signature for introspection
- */
-export declare function createAgent(source: string, vm: {
-    run: (ast: any, args: any, options?: any) => Promise<any>;
-}, runOptions?: {
-    fuel?: number;
-    capabilities?: any;
-}): ((args: Record<string, any>) => Promise<any>) & {
-    signature: FunctionSignature;
-    ast: SeqNode;
-};
-/**
- * Get tool definitions from a set of agent functions
- */
-export declare function getToolDefinitions(agents: Record<string, {
-    signature: FunctionSignature;
-}>): Array<{
-    type: 'function';
-    function: {
-        name: string;
-        description?: string;
-        parameters: {
-            type: 'object';
-            properties: Record<string, any>;
-            required: string[];
-        };
-    };
-}>;
-/**
- * Transpile TJS source to JavaScript with type metadata.
- * Works as both a function and a tagged template literal.
- */
-export declare function tjs(strings: TemplateStringsArray, ...values: any[]): TJSTranspileResult;
-export declare function tjs(source: string, options?: TJSTranspileOptions): TJSTranspileResult;

package/dist/src/lang/docs.d.ts

@@ -1,69 +0,0 @@
-/**
- * TJS Documentation Generator
- *
- * Dead simple: walk source in order, emit what you find.
- * - Doc blocks render as markdown
- * - Function signatures render as code blocks
- *
- * No magic pairing. No attachment logic. The signature IS the docs.
- * Doc blocks are just editorial commentary when you need it.
- */
-export interface DocResult {
-    /** Items in document order */
-    items: DocItem[];
-    /** Rendered markdown */
-    markdown: string;
-}
-export type DocItem = {
-    type: 'doc';
-    content: string;
-} | {
-    type: 'function';
-    name: string;
-    signature: string;
-};
-/**
- * Generate documentation from TJS source
- *
- * Walk source in document order. Emit doc blocks and function signatures.
- * Only extracts top-level doc blocks (outside function bodies).
- */
-export declare function generateDocs(source: string): DocResult;
-/**
- * Type metadata for a function parameter
- */
-export interface ParamTypeInfo {
-    type?: {
-        kind: string;
-    };
-    required?: boolean;
-    example?: any;
-}
-/**
- * Type metadata for a function
- */
-export interface FunctionTypeInfo {
-    params?: Record<string, ParamTypeInfo>;
-    returns?: {
-        kind: string;
-    };
-}
-/**
- * Generate markdown documentation with type metadata
- *
- * Combines source-level doc blocks with runtime type information.
- * Shows everything in document order:
- * - /*# ... *\/ comments render as markdown
- * - Functions render with signature and detailed type info
- *
- * @param source - TJS or TypeScript source code
- * @param types - Type metadata from transpiler (result.types)
- * @returns Formatted markdown documentation
- *
- * @example
- * ```typescript
- * const result = tjs(source)
- * const docs = generateDocsMarkdown(source, result.types)
- * ```
- */
-export declare function generateDocsMarkdown(source: string, types?: Record<string, FunctionTypeInfo>): string;

package/dist/src/lang/emitters/ast.d.ts

@@ -1,24 +0,0 @@
-/**
- * ESTree to Agent99 AST Transformer
- *
- * Converts parsed JavaScript into Agent99's JSON AST format.
- */
-import type { Statement, FunctionDeclaration, BlockStatement } from 'acorn';
-import type { BaseNode } from '../../builder';
-import type { TransformContext, TranspileOptions, FunctionSignature, TranspileWarning } from '../types';
-/**
- * Transform a function declaration into Agent99 AST
- */
-export declare function transformFunction(func: FunctionDeclaration, source: string, returnTypeAnnotation: string | undefined, options?: TranspileOptions, requiredParamsFromPreprocess?: Set<string>): {
-    ast: BaseNode;
-    signature: FunctionSignature;
-    warnings: TranspileWarning[];
-};
-/**
- * Transform a block statement into a list of steps
- */
-export declare function transformBlock(block: BlockStatement, ctx: TransformContext): BaseNode[];
-/**
- * Transform a statement
- */
-export declare function transformStatement(stmt: Statement, ctx: TransformContext): BaseNode | BaseNode[] | null;

package/dist/src/lang/emitters/dts.d.ts

@@ -1,48 +0,0 @@
-/**
- * TJS to .d.ts Emitter
- *
- * Generates TypeScript declaration files from TJS transpilation results.
- * Allows TypeScript consumers to use TJS-authored libraries with full
- * type information for functions, and helpful `any`-based stubs for
- * classes, generics, and predicate types.
- *
- * Design principle: emit enough structure for autocomplete/tooltips
- * (parameter names, object shapes) but lean on `any` where TJS types
- * can't be faithfully expressed in TS (predicate types, generics,
- * class instances). This gives developers IDE hints without false
- * lint errors from types that don't fully match.
- *
- * Handles:
- *   - Exported functions → full param/return types from TJSTypeInfo
- *   - Exported classes → callable function stub with constructor params, returns any
- *   - Exported Type declarations → type guard function stubs
- *   - Exported Generic declarations → factory function stubs
- *   - Re-exports via `export { Name }` syntax
- */
-import type { TypeDescriptor } from '../types';
-import type { TJSTranspileResult } from './js';
-/**
- * Convert a TypeDescriptor to a TypeScript type string.
- *
- * Maps TJS's example-inferred types to the closest TS equivalents:
- *   integer / non-negative-integer → number (TS has no integer type)
- *   string / number / boolean / null / undefined / any → themselves
- *   array + items → T[]
- *   object + shape → { key: Type; ... }
- *   union + members → T1 | T2
- *   nullable → T | null
- */
-export declare function typeDescriptorToTS(td: TypeDescriptor): string;
-export interface GenerateDTSOptions {
-    /** Module name for ambient declarations (omit for module-mode .d.ts) */
-    moduleName?: string;
-}
-/**
- * Generate a .d.ts string from TJS transpilation output.
- *
- * @param result - The TJSTranspileResult from tjs()
- * @param source - The original TJS source (needed to detect exports)
- * @param options - Generation options
- * @returns The .d.ts file content as a string
- */
-export declare function generateDTS(result: TJSTranspileResult, source: string, options?: GenerateDTSOptions): string;