import type { SpecialExpressionType } from '../builtin';
import type { Arity } from '../builtin/interface';
import type { specialExpressionTypes } from '../builtin/specialExpressionTypes';
import type { FunctionType, NodeType, NodeTypes } from '../constants/constants';
import type { Context } from '../evaluator/interface';
import type { Any, Arr, Coll } from '../interface';
import type { ReservedSymbol } from '../tokenizer/reservedNames';
import type { SourceCodeInfo } from '../tokenizer/token';
import type { ATOM_SYMBOL, EFFECT_SYMBOL, FUNCTION_SYMBOL, REGEXP_SYMBOL } from '../utils/symbols';
export type EvaluatedFunction = [BindingTarget[], AstNode[], Context];
interface GenericDvalaFunction {
    [FUNCTION_SYMBOL]: true;
    sourceCodeInfo?: SourceCodeInfo;
    functionType: FunctionType;
    arity: Arity;
}
export interface RegularExpression {
    [REGEXP_SYMBOL]: true;
    sourceCodeInfo?: SourceCodeInfo;
    s: string;
    f: string;
}
/** Dotted DNS-style identifier for entities with public identity (effects, macros, modules). */
export type QualifiedName = string;
export interface EffectRef {
    [EFFECT_SYMBOL]: true;
    name: QualifiedName;
}
/** Atom: a self-evaluating named constant, e.g. :ok, :error */
export interface Atom {
    [ATOM_SYMBOL]: true;
    name: string;
}
export interface UserDefinedFunction extends GenericDvalaFunction {
    functionType: 'UserDefined';
    name: string | undefined;
    evaluatedfunction: EvaluatedFunction;
    docString: string;
}
export interface MacroFunction extends GenericDvalaFunction {
    functionType: 'Macro';
    name: string | undefined;
    evaluatedfunction: EvaluatedFunction;
    docString: string;
}
export interface PartialFunction extends GenericDvalaFunction {
    functionType: 'Partial';
    function: FunctionLike;
    params: Arr;
    placeholders: number[];
}
export interface CompFunction extends GenericDvalaFunction {
    functionType: 'Comp';
    params: Arr;
}
export interface ConstantlyFunction extends GenericDvalaFunction {
    functionType: 'Constantly';
    value: Any;
}
export interface JuxtFunction extends GenericDvalaFunction {
    functionType: 'Juxt';
    params: Arr;
}
export interface ComplementFunction extends GenericDvalaFunction {
    functionType: 'Complement';
    function: FunctionLike;
}
export interface EveryPredFunction extends GenericDvalaFunction {
    functionType: 'EveryPred';
    params: Arr;
}
export interface SomePredFunction extends GenericDvalaFunction {
    functionType: 'SomePred';
    params: Arr;
}
export interface FNullFunction extends GenericDvalaFunction {
    functionType: 'Fnull';
    function: FunctionLike;
    params: Arr;
}
export interface QualifiedMatcherFunction extends GenericDvalaFunction {
    functionType: 'QualifiedMatcher';
    matchType: 'string' | 'regexp';
    pattern: string;
    flags: string;
}
export interface NormalBuiltinFunction extends GenericDvalaFunction {
    functionType: 'Builtin';
    normalBuiltinSymbolType: string;
    name: string;
}
export interface SpecialBuiltinFunction extends GenericDvalaFunction {
    functionType: 'SpecialBuiltin';
    specialBuiltinSymbolType: typeof specialExpressionTypes['&&'] | typeof specialExpressionTypes['||'] | typeof specialExpressionTypes['array'] | typeof specialExpressionTypes['object'] | typeof specialExpressionTypes['recur'] | typeof specialExpressionTypes['??'];
}
export interface ModuleFunction extends GenericDvalaFunction {
    functionType: 'Module';
    moduleName: string;
    functionName: string;
}
/**
 * A handler clause: maps an effect name to a body expression.
 * params are the binding targets for the effect's arguments.
 */
export interface HandlerClause {
    effectName: string;
    params: BindingTarget[];
    body: AstNode[];
}
/**
 * First-class handler value created by `handler...end`.
 * Contains named effect clauses and an optional transform clause.
 * When installed (via `h(-> body)` or `with h;`), provides algebraic effect handling
 * with resume/abort semantics.
 */
export interface HandlerFunction extends GenericDvalaFunction {
    functionType: 'Handler';
    clauses: HandlerClause[];
    clauseMap: Map<string, HandlerClause>;
    /** Transform clause: [paramBindingTarget, bodyExprs]. Defaults to identity. */
    transform: [BindingTarget, AstNode[]] | null;
    /** If true, shallow handler — resume does NOT reinstall the handler around the continuation. */
    shallow: boolean;
    /** Closure environment captured at handler creation. */
    closureEnv: unknown;
}
/**
 * First-class resume function created when a handler clause is entered.
 * When called with a value, it resumes the continuation at the perform site
 * with the handler reinstalled (deep semantics).
 */
export interface ResumeFunction extends GenericDvalaFunction {
    functionType: 'Resume';
    /** Reference to the HandlerClauseFrame that owns this resume.
     *  Used to check one-shot guard and set resumed flag. */
    clauseFrame: unknown;
    /** The handler to reinstall on resume (deep semantics). */
    handler: HandlerFunction;
    /** Continuation from perform site up to the AlgebraicHandleFrame. */
    performK: unknown;
    /** Handler environment for reinstallation. */
    handlerEnv: unknown;
}
export type DvalaFunction = UserDefinedFunction | MacroFunction | NormalBuiltinFunction | SpecialBuiltinFunction | ModuleFunction | PartialFunction | CompFunction | ConstantlyFunction | JuxtFunction | ComplementFunction | EveryPredFunction | SomePredFunction | FNullFunction | QualifiedMatcherFunction | HandlerFunction | ResumeFunction;
export type DvalaFunctionType = DvalaFunction['functionType'];
export type FunctionLike = DvalaFunction | Coll | number;
export type AstNode<T extends NodeType = NodeType, Payload = unknown> = [T, Payload, number];
export type SpreadNode = AstNode<typeof NodeTypes.Spread, AstNode>;
export type NumberNode = AstNode<typeof NodeTypes.Num, number>;
export type StringNode = AstNode<typeof NodeTypes.Str, string>;
export type AtomNode = AstNode<typeof NodeTypes.Atom, string>;
export type TemplateStringNode = AstNode<typeof NodeTypes.TmplStr, (StringNode | AstNode)[]>;
export type ExpressionNode = NormalExpressionNode | SpecialExpressionNode | NumberNode | StringNode | AtomNode | TemplateStringNode;
export type UserDefinedSymbolNode = AstNode<typeof NodeTypes.Sym, string>;
export type BuiltinSymbolNode = AstNode<typeof NodeTypes.Builtin, string>;
export type SpecialSymbolNode = AstNode<typeof NodeTypes.Special, SpecialExpressionType>;
export type SymbolNode = UserDefinedSymbolNode | BuiltinSymbolNode | SpecialSymbolNode;
export type ReservedNode = AstNode<typeof NodeTypes.Reserved, ReservedSymbol>;
export type EffectNameNode = AstNode<typeof NodeTypes.Effect, string>;
export type SpecialExpressionNode<T extends [SpecialExpressionType, ...unknown[]] = [SpecialExpressionType, ...unknown[]]> = AstNode<typeof NodeTypes.SpecialExpression, T>;
/**
 * Formatting hints stored in Call node payloads.
 * Set at parse time to preserve authored syntactic form through formatting.
 */
export interface CallHints {
    /** True when authored as infix: `a foo b` rather than `foo(a, b)`. */
    isInfix?: boolean;
    /** True when authored as pipe: `a |> b` rather than `b(a)`. */
    isPipe?: boolean;
}
export type NormalExpressionNodeWithName = AstNode<typeof NodeTypes.Call, [BuiltinSymbolNode | UserDefinedSymbolNode, AstNode[], CallHints?]>;
export type NormalExpressionNodeExpression = AstNode<typeof NodeTypes.Call, [AstNode, AstNode[], CallHints?]>;
export type NormalExpressionNode = NormalExpressionNodeWithName | NormalExpressionNodeExpression;
export declare const bindingTargetTypes: {
    readonly symbol: "symbol";
    readonly rest: "rest";
    readonly object: "object";
    readonly array: "array";
    readonly literal: "literal";
    readonly wildcard: "wildcard";
};
export type BindingTargetType = typeof bindingTargetTypes[keyof typeof bindingTargetTypes];
type GenericTarget<T extends BindingTargetType, Payload extends unknown[]> = [T, Payload, number];
export type SymbolBindingTarget = GenericTarget<typeof bindingTargetTypes.symbol, [SymbolNode, AstNode | undefined]>;
export type RestBindingTarget = GenericTarget<typeof bindingTargetTypes.rest, [string, AstNode | undefined]>;
export type ObjectBindingTarget = GenericTarget<typeof bindingTargetTypes.object, [Record<string, BindingTarget>, AstNode | undefined]>;
export type ArrayBindingTarget = GenericTarget<typeof bindingTargetTypes.array, [(BindingTarget | null)[], AstNode | undefined]>;
export type LiteralBindingTarget = GenericTarget<typeof bindingTargetTypes.literal, [AstNode]>;
export type WildcardBindingTarget = GenericTarget<typeof bindingTargetTypes.wildcard, []>;
export type BindingTarget = SymbolBindingTarget | RestBindingTarget | ObjectBindingTarget | ArrayBindingTarget | LiteralBindingTarget | WildcardBindingTarget;
export type BindingNode = AstNode<typeof NodeTypes.Binding, [BindingTarget, AstNode]>;
export interface SourceMapPosition {
    source: number;
    start: [number, number];
    end: [number, number];
    /** True for Sym/Builtin/Special/Reserved/Effect — never tracked by the evaluator's onNodeEval hook */
    structuralLeaf?: boolean;
}
export interface SourceMap {
    sources: {
        path: string;
        content: string;
    }[];
    positions: Map<number, SourceMapPosition>;
}
export declare function resolveSourceCodeInfo(nodeId: number, sourceMap: SourceMap | undefined): SourceCodeInfo | undefined;
type AstBody = AstNode[];
/** Parsed effect declaration: effect @name(ArgType) -> RetType */
export interface EffectDeclarationInfo {
    argType: string;
    retType: string;
}
/** Parsed type alias: type Name<Params> = Body */
export interface TypeAliasInfo {
    params: string[];
    body: string;
}
export interface Ast {
    body: AstBody;
    sourceMap?: SourceMap;
    /** Type annotations from source code, keyed by nodeId. Erased before evaluation. */
    typeAnnotations?: Map<number, string>;
    /** Effect declarations from source code. Erased before evaluation. */
    effectDeclarations?: Map<string, EffectDeclarationInfo>;
    /** Type alias declarations from source code. Erased before evaluation. */
    typeAliases?: Map<string, TypeAliasInfo>;
}
export {};