import { type RuntimeValidator } from '../../validation/lightweight-validators';
import type { HyperScriptValue, EvaluationResult, ValidationResult } from '../../types/command-types';
import type { TypedExpressionContext } from '../../types/base-types';
import type { TypedExpressionImplementation } from '../../types/expression-types';
export declare const ObjectFieldSchema: RuntimeValidator<unknown>;
export type ObjectField = any;
export declare const ObjectLiteralInputSchema: RuntimeValidator<unknown>;
export type ObjectLiteralInput = any;
export declare class ObjectLiteralExpression implements TypedExpressionImplementation<Record<string, HyperScriptValue>> {
    readonly name = "ObjectLiteral";
    readonly category: "Special";
    readonly syntax = "{ key1: value1, key2: value2, ... }";
    readonly description = "Creates an object literal with specified key-value pairs";
    readonly inputSchema: RuntimeValidator<Record<string, HyperScriptValue>>;
    readonly outputType: "Object";
    readonly metadata: {
        category: "Special";
        complexity: "simple";
        sideEffects: never[];
        dependencies: never[];
        returnTypes: "Object"[];
        examples: ({
            input: string;
            description: string;
            expectedOutput: {
                x?: undefined;
                name?: undefined;
                age?: undefined;
            };
        } | {
            input: string;
            description: string;
            expectedOutput: {
                x: number;
                name?: undefined;
                age?: undefined;
            };
        } | {
            input: string;
            description: string;
            expectedOutput: {
                name: string;
                age: number;
                x?: undefined;
            };
        })[];
        relatedExpressions: string[];
        performance: {
            averageTime: number;
            complexity: "O(n)";
        };
    };
    validate(args: unknown): ValidationResult;
    evaluate(context: TypedExpressionContext, ...args: unknown[]): Promise<EvaluationResult<Record<string, HyperScriptValue>>>;
    private resolveFieldKey;
    private resolveFieldValue;
    getMetadata(): {
        name: string;
        category: "literal";
        version: string;
        description: string;
        inputSchema: RuntimeValidator<Record<string, unknown>>;
        supportedFeatures: string[];
        performance: {
            complexity: string;
            averageExecutionTime: string;
            memoryUsage: string;
        };
        capabilities: {
            contextAware: boolean;
            supportsAsync: boolean;
            sideEffects: boolean;
            cacheable: boolean;
        };
    };
}
export declare function createObjectLiteralExpression(): ObjectLiteralExpression;
export declare function isValidObjectLiteralInput(args: unknown[]): args is ObjectLiteralInput;
export declare function createField(key: string | unknown, value: unknown, isDynamic?: boolean): ObjectField;
export declare function createStaticField(key: string, value: unknown): ObjectField;
export declare function createDynamicField(keyExpression: unknown, value: unknown): ObjectField;
export declare function createObject(fields: ObjectField[], context: TypedExpressionContext): Promise<EvaluationResult<Record<string, HyperScriptValue>>>;
export { ObjectLiteralExpression as default };
//# sourceMappingURL=index.d.ts.map