import type { BaseTypedExpression, TypedExpressionContext, EvaluationType, ExpressionMetadata, ValidationResult, EvaluationResult } from '../../../types/base-types';
import type { ExpressionCategory } from '../../../types/expression-types';
import { BaseExpressionImpl } from '../../base-expression';
type PropertyAccessInput = any;
type AttributeAccessInput = any;
type ContextPropertyInput = any;
type AttributeWithValueInput = any;
export declare class PossessiveExpression extends BaseExpressionImpl<PropertyAccessInput, unknown> implements BaseTypedExpression<unknown> {
    readonly name = "possessive";
    readonly category: ExpressionCategory;
    readonly syntax = "element's property";
    readonly description = "Access object or element properties using possessive syntax";
    readonly inputSchema: import("../../../validation/lightweight-validators").RuntimeValidator<{
        [x: string]: unknown;
    }>;
    readonly outputType: EvaluationType;
    readonly metadata: ExpressionMetadata;
    evaluate(context: TypedExpressionContext, input: PropertyAccessInput): Promise<EvaluationResult<unknown>>;
    validate(input: unknown): ValidationResult;
    private getProperty;
    private getElementProperty;
    private inferResultType;
}
export declare class MyExpression extends BaseExpressionImpl<ContextPropertyInput, unknown> implements BaseTypedExpression<unknown> {
    readonly name = "my";
    readonly category: ExpressionCategory;
    readonly syntax = "my property";
    readonly description = "Access properties of the current context element (me)";
    readonly inputSchema: import("../../../validation/lightweight-validators").RuntimeValidator<{
        [x: string]: unknown;
    }>;
    readonly outputType: EvaluationType;
    readonly metadata: ExpressionMetadata;
    evaluate(context: TypedExpressionContext, input: ContextPropertyInput): Promise<EvaluationResult<unknown>>;
    validate(input: unknown): ValidationResult;
}
export declare class ItsExpression extends BaseExpressionImpl<ContextPropertyInput, unknown> implements BaseTypedExpression<unknown> {
    readonly name = "its";
    readonly category: ExpressionCategory;
    readonly syntax = "its property";
    readonly description = "Access properties of the it reference in context";
    readonly inputSchema: import("../../../validation/lightweight-validators").RuntimeValidator<{
        [x: string]: unknown;
    }>;
    readonly outputType: EvaluationType;
    readonly metadata: ExpressionMetadata;
    evaluate(context: TypedExpressionContext, input: ContextPropertyInput): Promise<EvaluationResult<unknown>>;
    validate(input: unknown): ValidationResult;
}
export declare class YourExpression extends BaseExpressionImpl<ContextPropertyInput, unknown> implements BaseTypedExpression<unknown> {
    readonly name = "your";
    readonly category: ExpressionCategory;
    readonly syntax = "your property";
    readonly description = "Access properties of the you reference in context";
    readonly inputSchema: import("../../../validation/lightweight-validators").RuntimeValidator<{
        [x: string]: unknown;
    }>;
    readonly outputType: EvaluationType;
    readonly metadata: ExpressionMetadata;
    evaluate(context: TypedExpressionContext, input: ContextPropertyInput): Promise<EvaluationResult<unknown>>;
    validate(input: unknown): ValidationResult;
}
export declare class AttributeExpression extends BaseExpressionImpl<AttributeAccessInput, string | null> implements BaseTypedExpression<string | null> {
    readonly name = "attribute";
    readonly category: ExpressionCategory;
    readonly syntax = "@attribute or @attribute of element";
    readonly description = "Access HTML attributes of DOM elements";
    readonly inputSchema: import("../../../validation/lightweight-validators").RuntimeValidator<{
        [x: string]: unknown;
    }>;
    readonly outputType: EvaluationType;
    readonly metadata: ExpressionMetadata;
    evaluate(context: TypedExpressionContext, input: AttributeAccessInput): Promise<EvaluationResult<string | null>>;
    validate(input: unknown): ValidationResult;
}
export declare class AttributeWithValueExpression extends BaseExpressionImpl<AttributeWithValueInput, boolean> implements BaseTypedExpression<boolean> {
    readonly name = "attributeWithValue";
    readonly category: ExpressionCategory;
    readonly syntax = "@attribute=value";
    readonly description = "Check if element has attribute with specific value";
    readonly inputSchema: import("../../../validation/lightweight-validators").RuntimeValidator<{
        [x: string]: unknown;
    }>;
    readonly outputType: EvaluationType;
    readonly metadata: ExpressionMetadata;
    evaluate(context: TypedExpressionContext, input: AttributeWithValueInput): Promise<EvaluationResult<boolean>>;
    validate(input: unknown): ValidationResult;
}
export declare function createPossessiveExpression(): PossessiveExpression;
export declare function createMyExpression(): MyExpression;
export declare function createItsExpression(): ItsExpression;
export declare function createYourExpression(): YourExpression;
export declare function createAttributeExpression(): AttributeExpression;
export declare function createAttributeWithValueExpression(): AttributeWithValueExpression;
export declare const propertyExpressions: {
    readonly possessive: PossessiveExpression;
    readonly my: MyExpression;
    readonly its: ItsExpression;
    readonly your: YourExpression;
    readonly attribute: AttributeExpression;
    readonly attributeWithValue: AttributeWithValueExpression;
};
export type PropertyExpressionName = keyof typeof propertyExpressions;
export {};
//# sourceMappingURL=index.d.ts.map