/**
 * Quint → TypeScript Transpiler
 *
 * Transpiles Quint `pure def` functions and `val` invariants into
 * TypeScript guard functions for runtime validation.
 *
 * Handles a subset of Quint syntax:
 * - pure def name(params): type = { body }
 * - val name: bool = expression
 * - if/else expressions
 * - and/or/not/implies operators
 * - comparison operators (==, !=, >=, <=, >, <)
 * - arithmetic (+, -, *, /, %)
 * - forall/exists quantifiers (transpiled to .every/.some)
 * - set operations (.contains, .size, .filter, .map, .union)
 */
export interface TranspiledGuard {
    name: string;
    kind: 'function' | 'invariant';
    quint: string;
    typescript: string;
    module: string;
    entity: string;
    /**
     * State variables this guard reads from. Used by the verification
     * runner to decide whether the guard is applicable to a given spec
     * snapshot: if any dependency is not present in the snapshot, the
     * guard is skipped (not failed).
     */
    dependencies: string[];
}
/**
 * Transpile all Quint files from entity modules into TypeScript guards.
 */
export declare function transpileEntityGuards(entitiesDir: string): TranspiledGuard[];
/**
 * Scan Quint behaviour files for module-level `var X: ...` declarations.
 * These are the state variables guards read from; the runtime host
 * populates them via `setSpecSnapshot` before invoking any `check_*`.
 */
export declare function extractStateVariables(entitiesDir: string): string[];
/**
 * Transpile a single Quint file into TypeScript guards.
 */
export declare function transpileQuintFile(content: string, entity: string, filename: string): TranspiledGuard[];
/**
 * Generate a TypeScript guards module from transpiled guards.
 *
 * `stateVars` is the list of Quint module-level `var` declarations the
 * guards reference. When omitted, falls back to a minimal hard-coded
 * set — but callers should pass the real list from `extractStateVariables`.
 */
export declare function generateGuardsModule(guards: TranspiledGuard[], stateVars?: string[]): string;
export interface TranspiledAction {
    name: string;
    params: string;
    guards: string[];
    effects: string[];
    events: string[];
    quint: string;
    typescript: string;
    module: string;
    entity: string;
}
/**
 * Transpile Quint action definitions into async TypeScript methods.
 *
 * Quint actions follow the pattern:
 *   action name(params): bool = all {
 *     guard1,                          // → precondition check
 *     guard2,                          // → precondition check
 *     model' = { ...model, field: x }, // → prisma update
 *     emit(EventName, payload),        // → event emission
 *   }
 */
export declare function transpileActions(content: string, entity: string, filename: string): TranspiledAction[];
/**
 * Generate a TypeScript module from transpiled actions.
 */
export declare function generateActionsModule(actions: TranspiledAction[]): string;
//# sourceMappingURL=quint-transpiler.d.ts.map