import type { Callable, Context, Isolate, Script } from "./types";
export type TypeScriptLoader = "ts" | "tsx";
export type SourceFileLoader = "js" | "jsx" | "ts" | "tsx";
export type TranspileTypeScriptOptions = {
    /**
     * Bun loader used for the source. Use `"tsx"` / `"jsx"` when tenant/plugin
     * source may contain JSX syntax.
     */
    loader?: SourceFileLoader;
    /**
     * Bun transpilation target. Defaults to `"bun"` because isolate code runs
     * inside Bun/JavaScriptCore.
     */
    target?: "bun" | "browser" | "node";
};
export type SourceFileOptions = TranspileTypeScriptOptions & {
    /**
     * Override the loader inferred from the file extension.
     */
    loader?: SourceFileLoader;
};
/**
 * Transpile TypeScript with Bun's native transpiler before sending source to
 * the isolate. This does not type-check; run `tsc --noEmit` separately when
 * you need diagnostics.
 */
export declare const transpileTypeScript: (source: string, options?: TranspileTypeScriptOptions) => string;
/**
 * Read a real source file from disk. This is intentionally a tiny helper so
 * callers can keep tenant/plugin code in normal `.ts`, `.tsx`, `.js`, or
 * `.jsx` files with editor diagnostics, generics, and stack-friendly names.
 */
export declare const readSourceFile: (filePath: string | URL) => Promise<string>;
/**
 * Read and transpile a source file with Bun's native transpiler. The loader is
 * inferred from `.ts`, `.tsx`, `.js`, `.jsx`, `.mjs`, or `.cjs` unless supplied.
 */
export declare const transpileSourceFile: (filePath: string | URL, options?: SourceFileOptions) => Promise<string>;
/**
 * Transpile TypeScript and compile it as an isolate script.
 */
export declare const compileTypeScript: (isolate: Isolate, source: string, options?: TranspileTypeScriptOptions) => Promise<Script>;
/**
 * Read a `.ts`, `.tsx`, `.js`, or `.jsx` file, transpile it with Bun, and
 * compile it as an isolate script.
 */
export declare const compileTypeScriptFile: (isolate: Isolate, filePath: string | URL, options?: SourceFileOptions) => Promise<Script>;
/**
 * Transpile a TypeScript function expression and compile it as a reusable
 * callable. The export wrapper keeps Bun's transpiler from dropping a bare
 * arrow function expression, then we pass the resulting function expression to
 * Context.compileCallable.
 */
export declare const compileTypeScriptCallable: (context: Context, source: string, options?: TranspileTypeScriptOptions) => Promise<Callable>;
/**
 * Read a source file whose default export is a function and transpile it into
 * the callable expression consumed by {@link Context.compileCallable}.
 */
export declare const transpileSourceFileCallable: (filePath: string | URL, options?: SourceFileOptions) => Promise<string>;
/**
 * Read a source file whose default export is a function, transpile it with Bun,
 * and compile that default export as a reusable isolate callable.
 *
 * Example file:
 *
 * ```ts
 * type Box<T> = { value: T };
 * export default function unwrap<T>(box: Box<T>): T {
 *   return box.value;
 * }
 * ```
 */
export declare const compileTypeScriptCallableFile: (context: Context, filePath: string | URL, options?: SourceFileOptions) => Promise<Callable>;