import { type RuntimeValidator } from '../../validation/lightweight-validators';
import type { HyperScriptValue, EvaluationResult } from '../../types/command-types';
import type { ValidationResult, TypedExpressionContext } from '../../types/base-types';
import type { TypedExpressionImplementation } from '../../types/expression-types';
export declare const ArrayLiteralInputSchema: RuntimeValidator<unknown>;
export type ArrayLiteralInput = any;
export declare const ArrayIndexInputSchema: RuntimeValidator<unknown>;
export type ArrayIndexInput = any;
export declare class ArrayLiteralExpression implements TypedExpressionImplementation<HyperScriptValue[]> {
    readonly name = "ArrayLiteral";
    readonly category: "Special";
    readonly syntax = "[element1, element2, ...]";
    readonly description = "Creates an array literal with specified elements";
    readonly inputSchema: RuntimeValidator<HyperScriptValue[]>;
    readonly outputType: "Array";
    readonly metadata: {
        category: "Special";
        complexity: "simple";
        sideEffects: never[];
        dependencies: never[];
        returnTypes: "Array"[];
        examples: ({
            input: string;
            description: string;
            expectedOutput: number[];
        } | {
            input: string;
            description: string;
            expectedOutput: string[];
        })[];
        relatedExpressions: string[];
        performance: {
            averageTime: number;
            complexity: "O(n)";
        };
    };
    validate(args: unknown[]): ValidationResult;
    evaluate(_context: TypedExpressionContext, ...args: unknown[]): Promise<EvaluationResult<HyperScriptValue[]>>;
    getMetadata(): {
        name: string;
        category: "literal";
        version: string;
        description: string;
        inputSchema: RuntimeValidator<unknown[]>;
        supportedFeatures: string[];
        performance: {
            complexity: string;
            averageExecutionTime: string;
            memoryUsage: string;
        };
        capabilities: {
            contextAware: boolean;
            supportsAsync: boolean;
            sideEffects: boolean;
            cacheable: boolean;
        };
    };
}
export declare class ArrayIndexExpression implements TypedExpressionImplementation<HyperScriptValue> {
    readonly name = "ArrayIndex";
    readonly category: "Special";
    readonly syntax = "array[index]";
    readonly description = "Accesses an array element by index or extracts a slice";
    readonly inputSchema: RuntimeValidator<unknown>;
    readonly outputType: "Any";
    readonly metadata: {
        category: "Special";
        complexity: "simple";
        sideEffects: never[];
        dependencies: never[];
        returnTypes: "Any"[];
        examples: {
            input: string;
            description: string;
            expectedOutput: undefined;
        }[];
        relatedExpressions: string[];
        performance: {
            averageTime: number;
            complexity: "O(1)";
        };
    };
    validate(args: unknown[]): ValidationResult;
    evaluate(_context: TypedExpressionContext, ...args: unknown[]): Promise<EvaluationResult<HyperScriptValue>>;
    private normalizeArrayTarget;
    private performIndexOperation;
    getMetadata(): {
        name: string;
        category: "access";
        version: string;
        description: string;
        inputSchema: RuntimeValidator<unknown>;
        supportedFeatures: string[];
        performance: {
            complexity: string;
            averageExecutionTime: string;
            memoryUsage: string;
        };
        capabilities: {
            contextAware: boolean;
            supportsAsync: boolean;
            sideEffects: boolean;
            cacheable: boolean;
        };
    };
}
export declare function createArrayLiteralExpression(): ArrayLiteralExpression;
export declare function createArrayIndexExpression(): ArrayIndexExpression;
export declare function isValidArrayLiteralInput(args: unknown[]): args is ArrayLiteralInput;
export declare function isValidArrayIndexInput(args: unknown[]): args is ArrayIndexInput;
export declare function createArray(elements: unknown[], context: TypedExpressionContext): Promise<EvaluationResult<HyperScriptValue[]>>;
export declare function indexArray(target: unknown, index: number | string | {
    start?: number;
    end?: number;
}, context: TypedExpressionContext): Promise<EvaluationResult<HyperScriptValue>>;
export { ArrayLiteralExpression as default };
//# sourceMappingURL=index.d.ts.map