import { Expression } from 'estree';
import { IKeyedInstanceFactory } from '@rs-x/core';
import { E as ExpressionType, f as IExpression } from './expression-bind-configuration.type-DGqrNXib.js';

interface ICompiledExpressionWatchDependency {
    readonly name: string;
    readonly ownerPath: readonly string[];
    readonly isLeaf: boolean;
    readonly isMemberExpressionSegment: boolean;
}
interface ICompiledMemberChainSegment {
    readonly kind: 'static' | 'computed';
    readonly key?: string | number;
    readonly expressionString?: string;
    readonly dependencyNames?: readonly string[];
    readonly evaluateIndex?: (...args: unknown[]) => unknown;
    readonly evaluateIndexByOwnDependencies?: (...args: unknown[]) => unknown;
}
interface ICompiledMemberChainPlan {
    readonly rootIdentifier: string;
    readonly segments: readonly ICompiledMemberChainSegment[];
}
interface ICompiledExpressionPlan {
    readonly expressionString: string;
    readonly dependencyNames: readonly string[];
    readonly watchDependencies: readonly ICompiledExpressionWatchDependency[];
    readonly expressionType: ExpressionType;
    readonly hasHiddenArgumentArray: boolean;
    readonly memberChain?: ICompiledMemberChainPlan;
    readonly sequenceOperands?: readonly ICompiledSequenceOperandPlan[];
    evaluate(...args: unknown[]): unknown;
    evaluateResolvedDependencies?(model: unknown, identifierOwnerResolver: unknown, indexValueAccessor: unknown, normalizeDependencyValue: unknown, wrapForRuntimeEvaluation: unknown): unknown;
}
interface ICompiledSequenceOperandPlan {
    readonly expressionString: string;
    readonly dependencyNames: readonly string[];
    evaluate(...args: unknown[]): unknown;
}
interface ICompiledExpressionCompiler {
    tryCompile(expressionString: string): ICompiledExpressionPlan | undefined;
}

interface IExpressionCacheData {
    expressionString: string;
    /** When set, overrides the global engine mode for this expression. */
    compiled?: boolean;
    /** When true, defer AOT readiness until the lazy preloader resolves. */
    lazy?: boolean;
    /**
     * When set, the expression belongs to this named lazy group.
     * On first use, the entire group's manifest is loaded — not just this
     * expression — keeping the number of dynamic imports small.
     * Implies lazy: true.
     */
    lazyGroup?: string;
}
interface IExpressionCache extends IKeyedInstanceFactory<string, IExpressionCacheData, IExpression> {
    registerExpressionTree(expressionString: string, expressionTree: IExpression): void;
}

declare function registerLazyExpressionPreloader(expressionString: string, loader: () => void | Promise<void>): void;
declare function registerLazyExpressionPreloaders(loaders: Readonly<Record<string, () => void | Promise<void>>>): void;
/**
 * Register a loader for a named group of lazy expressions.
 * When any expression in the group is first needed, the group loader is
 * invoked once, registering all expressions in that group together.
 */
declare function registerLazyExpressionGroupPreloader(groupName: string, loader: () => void | Promise<void>): void;
/**
 * Declare that an expression belongs to a lazy group.
 * Called automatically by the generated lazy-group manifest on registration.
 */
declare function registerLazyExpressionInGroup(expressionString: string, groupName: string): void;
declare function hasLazyExpressionPreloader(expressionString: string): boolean;
declare function hasLazyGroupPreloader(groupName: string): boolean;
declare function getLazyExpressionGroup(expressionString: string): string | undefined;
declare function triggerLazyExpressionPreload(expressionString: string): void;
declare function startLazyExpressionPreload(expressionString: string): Promise<void> | undefined;
declare function startLazyGroupPreload(groupName: string): Promise<void> | undefined;
declare function clearLazyExpressionPreloaders(): void;

declare function registerPreparsedExpressionAst(expressionString: string, expressionAst: Expression): void;
declare function registerPreparsedExpressionAsts(expressionAsts: Readonly<Record<string, Expression>>): void;
declare function getPreparsedExpressionAst(expressionString: string): Expression | undefined;
declare function clearPreparsedExpressionAsts(): void;
declare function hydrateExpressionCacheWithPreparsedAsts(expressionCache: IExpressionCache): void;

declare function registerCompiledExpressionPlansInExpressionCache(plans: Readonly<Record<string, ICompiledExpressionPlan>>): void;
declare function registerCompiledExpressionPlanInExpressionCache(expressionString: string, plan: ICompiledExpressionPlan): void;
declare function getRegisteredCompiledExpressionPlan(expressionString: string): ICompiledExpressionPlan | undefined;
declare function hydrateExpressionCacheWithCompiledExpressionPlans(expressionCache: IExpressionCache): void;

export { triggerLazyExpressionPreload as A, type ICompiledExpressionPlan as I, type ICompiledExpressionCompiler as a, type IExpressionCacheData as b, type IExpressionCache as c, type ICompiledExpressionWatchDependency as d, type ICompiledMemberChainPlan as e, type ICompiledMemberChainSegment as f, type ICompiledSequenceOperandPlan as g, clearLazyExpressionPreloaders as h, clearPreparsedExpressionAsts as i, getLazyExpressionGroup as j, getPreparsedExpressionAst as k, getRegisteredCompiledExpressionPlan as l, hasLazyExpressionPreloader as m, hasLazyGroupPreloader as n, hydrateExpressionCacheWithCompiledExpressionPlans as o, hydrateExpressionCacheWithPreparsedAsts as p, registerCompiledExpressionPlansInExpressionCache as q, registerCompiledExpressionPlanInExpressionCache as r, registerLazyExpressionGroupPreloader as s, registerLazyExpressionInGroup as t, registerLazyExpressionPreloader as u, registerLazyExpressionPreloaders as v, registerPreparsedExpressionAst as w, registerPreparsedExpressionAsts as x, startLazyExpressionPreload as y, startLazyGroupPreload as z };