import type { TypedExpressionContext, EvaluationType, ValidationResult, EvaluationResult } from '../../../types/base-types';
import type { TypedExpressionImplementation, ExpressionMetadata, ExpressionCategory } from '../../../types/expression-types';
import { BaseExpressionImpl } from '../../base-expression';
type CollectionInput = any;
type IndexInput = any;
type RandomInput = any;
export declare class FirstExpression extends BaseExpressionImpl<CollectionInput, unknown> implements TypedExpressionImplementation<CollectionInput, unknown> {
    readonly name = "first";
    readonly category: ExpressionCategory;
    readonly syntax = "first in collection";
    readonly description = "Gets the first element from a collection";
    readonly inputSchema: import("../../../validation/lightweight-validators").RuntimeValidator<{
        [x: string]: unknown;
    }>;
    readonly outputType: EvaluationType;
    readonly metadata: ExpressionMetadata;
    evaluate(context: TypedExpressionContext, input: CollectionInput): Promise<EvaluationResult<unknown>>;
    validate(input: unknown): ValidationResult;
}
export declare class LastExpression extends BaseExpressionImpl<CollectionInput, unknown> implements TypedExpressionImplementation<CollectionInput, unknown> {
    readonly name = "last";
    readonly category: ExpressionCategory;
    readonly syntax = "last in collection";
    readonly description = "Gets the last element from a collection";
    readonly inputSchema: import("../../../validation/lightweight-validators").RuntimeValidator<{
        [x: string]: unknown;
    }>;
    readonly outputType: EvaluationType;
    readonly metadata: ExpressionMetadata;
    evaluate(context: TypedExpressionContext, input: CollectionInput): Promise<EvaluationResult<unknown>>;
    validate(input: unknown): ValidationResult;
}
export declare class AtExpression extends BaseExpressionImpl<IndexInput, unknown> implements TypedExpressionImplementation<IndexInput, unknown> {
    readonly name = "at";
    readonly category: ExpressionCategory;
    readonly syntax = "collection[index] or collection at index";
    readonly description = "Gets element at specific index from a collection";
    readonly inputSchema: import("../../../validation/lightweight-validators").RuntimeValidator<{
        [x: string]: unknown;
    }>;
    readonly outputType: EvaluationType;
    readonly metadata: ExpressionMetadata;
    evaluate(context: TypedExpressionContext, input: IndexInput): Promise<EvaluationResult<unknown>>;
    validate(input: unknown): ValidationResult;
    private normalizeIndex;
}
export declare class RandomExpression extends BaseExpressionImpl<RandomInput, unknown> implements TypedExpressionImplementation<RandomInput, unknown> {
    readonly name = "random";
    readonly category: ExpressionCategory;
    readonly syntax = "random in collection";
    readonly description = "Gets a random element from a collection";
    readonly inputSchema: import("../../../validation/lightweight-validators").RuntimeValidator<{
        [x: string]: unknown;
    }>;
    readonly outputType: EvaluationType;
    readonly metadata: ExpressionMetadata;
    evaluate(context: TypedExpressionContext, input: RandomInput): Promise<EvaluationResult<unknown>>;
    validate(input: unknown): ValidationResult;
    private getSecureRandomIndex;
}
export declare function createFirstExpression(): FirstExpression;
export declare function createLastExpression(): LastExpression;
export declare function createAtExpression(): AtExpression;
export declare function createRandomExpression(): RandomExpression;
export declare const positionalExpressions: {
    readonly first: FirstExpression;
    readonly last: LastExpression;
    readonly at: AtExpression;
    readonly random: RandomExpression;
};
export type PositionalExpressionName = keyof typeof positionalExpressions;
export {};
//# sourceMappingURL=index.d.ts.map