import type { ExecutionContext, TypedExpressionContext, ExpressionEvaluationOptions } from '../../../types/base-types';
export declare function createTypedExpressionContext(context: ExecutionContext, options?: ExpressionEvaluationOptions): TypedExpressionContext;
export declare function updateExecutionContext(originalContext: ExecutionContext, typedContext: TypedExpressionContext): ExecutionContext;
export declare class PositionalAdapter {
    static evaluateFirst(context: ExecutionContext, collection?: unknown): Promise<unknown>;
    static evaluateLast(context: ExecutionContext, collection?: unknown): Promise<unknown>;
    static evaluateAt(context: ExecutionContext, index: number, collection?: unknown): Promise<unknown>;
    static getExpressionMetadata(expressionName: string): import("../../../types/expression-types").ExpressionMetadata;
    static getExpressionDocumentation(expressionName: string): unknown;
    static validateExpressionInput(expressionName: string, input: unknown): import("../../../types/base-types").ValidationResult<unknown>;
}
export declare const EnhancedPositionalAdapter: typeof PositionalAdapter;
export declare class LegacyCompatibilityLayer {
    static firstExpression: {
        name: string;
        category: "Reference";
        evaluatesTo: "Any";
        evaluate(context: ExecutionContext, collection?: unknown): Promise<unknown>;
        validate(args: unknown[]): string | null;
    };
    static lastExpression: {
        name: string;
        category: "Reference";
        evaluatesTo: "Any";
        evaluate(context: ExecutionContext, collection?: unknown): Promise<unknown>;
        validate(args: unknown[]): string | null;
    };
    static atExpression: {
        name: string;
        category: "Reference";
        evaluatesTo: "Any";
        evaluate(context: ExecutionContext, index: number, collection?: unknown): Promise<unknown>;
        validate(args: unknown[]): string | null;
    };
}
export declare class ExpressionMigrationUtility {
    private static migrationMap;
    static enableEnhanced(expressionName: string): void;
    static disableEnhanced(expressionName: string): void;
    static isEnhancedEnabled(expressionName: string): boolean;
    static getMigrationStatus(): {
        [k: string]: boolean;
    };
    static enableAllEnhanced(): void;
    static disableAllEnhanced(): void;
}
export declare class PositionalUtilities {
    static safeFirst(context: ExecutionContext, collection?: unknown, fallback?: unknown): Promise<{
        success: boolean;
        value: unknown;
        error?: unknown;
    }>;
    static safeLast(context: ExecutionContext, collection?: unknown, fallback?: unknown): Promise<{
        success: boolean;
        value: unknown;
        error?: unknown;
    }>;
    static safeAt(context: ExecutionContext, index: number, collection?: unknown, fallback?: unknown): Promise<{
        success: boolean;
        value: unknown;
        error?: unknown;
    }>;
    static batchPositionalOperations(context: ExecutionContext, operations: Array<{
        type: 'first' | 'last' | 'at';
        collection: unknown;
        index?: number;
        key?: string;
    }>): Promise<{
        success: boolean;
        results: Record<string, unknown>;
        errors: Array<unknown>;
    }>;
    static getAvailableOperations(): {
        first: {
            description: string;
            complexity: string;
        };
        last: {
            description: string;
            complexity: string;
        };
        at: {
            description: string;
            complexity: string;
        };
    };
    static analyzeCollection(collection: unknown): {
        type: string;
        length: number;
        isIndexable: boolean;
        supportsNegativeIndexing: boolean;
        metadata: Record<string, unknown>;
    };
}
//# sourceMappingURL=bridge.d.ts.map