@hyperfixi/core 2.0.0

package/dist/expressions/references/impl/bridge.d.ts

@@ -0,0 +1,54 @@
+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 ExpressionAdapter {
+    static evaluateMe(context: ExecutionContext): Promise<HTMLElement | null>;
+    static evaluateYou(context: ExecutionContext): Promise<HTMLElement | null>;
+    static evaluateIt(context: ExecutionContext): Promise<unknown>;
+    static evaluateCSSSelector(context: ExecutionContext, selector: string, single?: boolean): Promise<HTMLElement | HTMLElement[] | null>;
+    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 class LegacyCompatibilityLayer {
+    static meExpression: {
+        name: string;
+        category: "Reference";
+        evaluatesTo: "Element";
+        evaluate(context: ExecutionContext): Promise<HTMLElement | null>;
+        validate(): null;
+    };
+    static youExpression: {
+        name: string;
+        category: "Reference";
+        evaluatesTo: "Element";
+        evaluate(context: ExecutionContext): Promise<HTMLElement | null>;
+        validate(): null;
+    };
+    static itExpression: {
+        name: string;
+        category: "Reference";
+        evaluatesTo: "Any";
+        evaluate(context: ExecutionContext): Promise<unknown>;
+        validate(): null;
+    };
+    static createQuerySelector(single?: boolean): {
+        name: string;
+        category: "Reference";
+        evaluatesTo: "Element" | "Array";
+        evaluate(context: ExecutionContext, selector: string): Promise<HTMLElement | HTMLElement[] | null>;
+        validate(args: any[]): 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;
+}
+//# sourceMappingURL=bridge.d.ts.map

package/dist/expressions/references/impl/index.d.ts

@@ -0,0 +1,65 @@
+import type { RuntimeValidator } from '../../../validation/lightweight-validators';
+import type { TypedExpressionImplementation, TypedExpressionContext, ExpressionMetadata, ExpressionCategory } from '../../../types/expression-types';
+import type { EvaluationResult, ValidationResult, EvaluationType } from '../../../types/command-types';
+import { BaseExpressionImpl } from '../../base-expression';
+export declare class MeExpression extends BaseExpressionImpl<undefined, HTMLElement | null> implements TypedExpressionImplementation<undefined, HTMLElement | null, TypedExpressionContext> {
+    readonly name: "me";
+    readonly category: ExpressionCategory;
+    readonly syntax = "me";
+    readonly description = "References the current element in the execution context";
+    readonly inputSchema: RuntimeValidator<undefined>;
+    readonly outputType: EvaluationType;
+    readonly metadata: ExpressionMetadata;
+    evaluate(context: TypedExpressionContext, input: undefined): Promise<EvaluationResult<HTMLElement | null>>;
+    validate(input: unknown): ValidationResult;
+}
+export declare class YouExpression extends BaseExpressionImpl<undefined, HTMLElement | null> implements TypedExpressionImplementation<undefined, HTMLElement | null, TypedExpressionContext> {
+    readonly name: "you";
+    readonly category: ExpressionCategory;
+    readonly syntax = "you";
+    readonly description = "References the target element (usually event target or command target)";
+    readonly inputSchema: RuntimeValidator<undefined>;
+    readonly outputType: EvaluationType;
+    readonly metadata: ExpressionMetadata;
+    evaluate(context: TypedExpressionContext, input: undefined): Promise<EvaluationResult<HTMLElement | null>>;
+    validate(input: unknown): ValidationResult;
+}
+export declare class ItExpression extends BaseExpressionImpl<undefined, unknown> implements TypedExpressionImplementation<undefined, unknown, TypedExpressionContext> {
+    readonly name: "it";
+    readonly category: ExpressionCategory;
+    readonly syntax = "it";
+    readonly description = "References the current context variable (result of previous operation or loop item)";
+    readonly inputSchema: RuntimeValidator<undefined>;
+    readonly outputType: EvaluationType;
+    readonly metadata: ExpressionMetadata;
+    evaluate(context: TypedExpressionContext, input: undefined): Promise<EvaluationResult<unknown>>;
+    validate(input: unknown): ValidationResult;
+}
+type CSSSelectorInput = any;
+export declare class CSSSelectorExpression extends BaseExpressionImpl<CSSSelectorInput, HTMLElement | HTMLElement[] | null> implements TypedExpressionImplementation<CSSSelectorInput, HTMLElement | HTMLElement[] | null, TypedExpressionContext> {
+    readonly name: "css-selector";
+    readonly category: ExpressionCategory;
+    readonly syntax = "<selector/> or <selector/> (single)";
+    readonly description = "Queries DOM elements using CSS selectors with validation";
+    readonly inputSchema: RuntimeValidator<{
+        [x: string]: unknown;
+    }>;
+    readonly outputType: EvaluationType;
+    readonly metadata: ExpressionMetadata;
+    evaluate(context: TypedExpressionContext, input: CSSSelectorInput): Promise<EvaluationResult<HTMLElement | HTMLElement[] | null>>;
+    validate(input: unknown): ValidationResult;
+    private isValidCSSSelector;
+    private getValidationSuggestion;
+}
+export declare const referenceExpressions: {
+    readonly me: MeExpression;
+    readonly you: YouExpression;
+    readonly it: ItExpression;
+    readonly 'css-selector': CSSSelectorExpression;
+};
+export declare function createMeExpression(): MeExpression;
+export declare function createYouExpression(): YouExpression;
+export declare function createItExpression(): ItExpression;
+export declare function createCSSSelectorExpression(): CSSSelectorExpression;
+export default referenceExpressions;
+//# sourceMappingURL=index.d.ts.map

package/dist/expressions/references/index.d.ts

@@ -0,0 +1,40 @@
+import type { ExpressionImplementation } from '../../types/core';
+export declare const meExpression: ExpressionImplementation;
+export declare const youExpression: ExpressionImplementation;
+export declare const itExpression: ExpressionImplementation;
+export declare const itsExpression: ExpressionImplementation;
+export declare const resultExpression: ExpressionImplementation;
+export declare const querySelectorExpression: ExpressionImplementation;
+export declare const querySelectorAllExpression: ExpressionImplementation;
+export declare const idExpression: ExpressionImplementation;
+export declare const classExpression: ExpressionImplementation;
+export declare const closestExpression: ExpressionImplementation;
+export declare const parentExpression: ExpressionImplementation;
+export declare const windowExpression: ExpressionImplementation;
+export declare const documentExpression: ExpressionImplementation;
+export declare const elementWithSelectorExpression: ExpressionImplementation;
+export declare const styleRefExpression: ExpressionImplementation;
+export declare const possessiveStyleRefExpression: ExpressionImplementation;
+export declare const ofStyleRefExpression: ExpressionImplementation;
+export declare const referencesExpressions: {
+    readonly me: ExpressionImplementation;
+    readonly you: ExpressionImplementation;
+    readonly it: ExpressionImplementation;
+    readonly its: ExpressionImplementation;
+    readonly result: ExpressionImplementation;
+    readonly querySelector: ExpressionImplementation;
+    readonly querySelectorAll: ExpressionImplementation;
+    readonly getElementById: ExpressionImplementation;
+    readonly getElementsByClassName: ExpressionImplementation;
+    readonly closest: ExpressionImplementation;
+    readonly parent: ExpressionImplementation;
+    readonly window: ExpressionImplementation;
+    readonly document: ExpressionImplementation;
+    readonly elementWithSelector: ExpressionImplementation;
+    readonly styleRef: ExpressionImplementation;
+    readonly possessiveStyleRef: ExpressionImplementation;
+    readonly ofStyleRef: ExpressionImplementation;
+};
+export type ReferenceExpressionName = keyof typeof referencesExpressions;
+export { MeExpression, YouExpression, ItExpression, CSSSelectorExpression, createMeExpression, createYouExpression, createItExpression, } from './impl/index';
+//# sourceMappingURL=index.d.ts.map

package/dist/expressions/shared/comparison-utils.d.ts

@@ -0,0 +1,10 @@
+export type ComparisonOperator = '>' | '<' | '>=' | '<=' | '==' | '!=' | '===' | '!==';
+export declare function compareValues(left: unknown, right: unknown, operator: ComparisonOperator): boolean;
+export declare function coerceToComparable(left: unknown, right: unknown): [number, number] | [string, string];
+export declare function areStrictlyEqual(left: unknown, right: unknown): boolean;
+export declare function areLooselyEqual(left: unknown, right: unknown): boolean;
+export declare function isGreaterThan(left: unknown, right: unknown): boolean;
+export declare function isLessThan(left: unknown, right: unknown): boolean;
+export declare function isGreaterThanOrEqual(left: unknown, right: unknown): boolean;
+export declare function isLessThanOrEqual(left: unknown, right: unknown): boolean;
+//# sourceMappingURL=comparison-utils.d.ts.map

package/dist/expressions/shared/index.d.ts

@@ -0,0 +1,9 @@
+export { toNumber, toNumberOrNull, ensureFinite, isNumeric, safeDivide, safeModulo, } from './number-utils';
+export { compareValues, coerceToComparable, areStrictlyEqual, areLooselyEqual, isGreaterThan, isLessThan, isGreaterThanOrEqual, isLessThanOrEqual, type ComparisonOperator, } from './comparison-utils';
+export { validResult, invalidResult, createError, toValidationResult, validateBinaryInput, validateUnaryInput, validateNotNull, validateNumber, validateString, validateBoolean, combineValidations, } from './validation-utils';
+export { isString, isNumber, isBoolean, isObject, isFunction, isArray, isElement, isArrayLike, inferType, } from '../type-helpers';
+export declare function trackEvaluation<T>(expression: {
+    name: string;
+    category: string;
+}, context: unknown, args: unknown[], result: T, startTime: number, success?: boolean, error?: Error): T;
+//# sourceMappingURL=index.d.ts.map

package/dist/expressions/shared/number-utils.d.ts

@@ -0,0 +1,7 @@
+export declare function toNumber(value: unknown, context: string): number;
+export declare function toNumberOrNull(value: unknown): number | null;
+export declare function ensureFinite(num: number, operation: string): number;
+export declare function isNumeric(value: unknown): boolean;
+export declare function safeDivide(left: number, right: number, allowInfinity?: boolean): number;
+export declare function safeModulo(left: number, right: number): number;
+//# sourceMappingURL=number-utils.d.ts.map

package/dist/expressions/shared/validation-utils.d.ts

@@ -0,0 +1,13 @@
+import type { ValidationResult, ValidationError } from '../../types/base-types';
+export declare function validResult(): ValidationResult;
+export declare function invalidResult(errors: ValidationError[], suggestions?: string[]): ValidationResult;
+export declare function createError(type: ValidationError['type'], message: string, suggestions?: string[], severity?: 'error' | 'warning' | 'info'): ValidationError;
+export declare function validateBinaryInput(input: unknown): ValidationResult;
+export declare function validateUnaryInput(input: unknown): ValidationResult;
+export declare function validateNotNull(value: unknown, name: string): ValidationResult;
+export declare function validateNumber(value: unknown, name: string): ValidationResult;
+export declare function validateString(value: unknown, name: string): ValidationResult;
+export declare function validateBoolean(value: unknown, name: string): ValidationResult;
+export declare function toValidationResult(result: string | null): ValidationResult;
+export declare function combineValidations(...results: ValidationResult[]): ValidationResult;
+//# sourceMappingURL=validation-utils.d.ts.map

package/dist/expressions/special/index.d.ts

@@ -0,0 +1,104 @@
+import { type RuntimeValidator } from '../../validation/lightweight-validators';
+import type { TypedExpressionContext, EvaluationType, ExpressionMetadata, ValidationResult, EvaluationResult } from '../../types/base-types';
+import type { ExpressionCategory } from '../../types/expression-types';
+import { BaseExpressionImpl } from '../base-expression';
+type StringLiteralInput = {
+    value: string;
+};
+type NumberLiteralInput = {
+    value: number;
+};
+type BooleanLiteralInput = {
+    value: boolean;
+};
+type BinaryOperationInput = {
+    left: unknown;
+    right: unknown;
+};
+export declare class StringLiteralExpression extends BaseExpressionImpl<StringLiteralInput, string> {
+    readonly name = "stringLiteral";
+    readonly category: ExpressionCategory;
+    readonly syntax = "\"string\" or 'string'";
+    readonly description = "String literals with template interpolation support";
+    readonly outputType: EvaluationType;
+    readonly inputSchema: RuntimeValidator<StringLiteralInput>;
+    readonly metadata: ExpressionMetadata;
+    evaluate(context: TypedExpressionContext, input: StringLiteralInput): Promise<EvaluationResult<string>>;
+    validate(input: unknown): ValidationResult;
+    private interpolateString;
+    private resolveExpression;
+    private resolveVariable;
+}
+export declare class NumberLiteralExpression extends BaseExpressionImpl<NumberLiteralInput, number> {
+    readonly name = "numberLiteral";
+    readonly category: ExpressionCategory;
+    readonly syntax = "123 or 3.14";
+    readonly description = "Numeric literal with validation";
+    readonly inputSchema: RuntimeValidator<NumberLiteralInput>;
+    readonly outputType: EvaluationType;
+    readonly metadata: ExpressionMetadata;
+    evaluate(context: TypedExpressionContext, input: NumberLiteralInput): Promise<EvaluationResult<number>>;
+    validate(input: unknown): ValidationResult;
+}
+export declare class BooleanLiteralExpression extends BaseExpressionImpl<BooleanLiteralInput, boolean> {
+    readonly name = "booleanLiteral";
+    readonly category: ExpressionCategory;
+    readonly syntax = "true or false";
+    readonly description = "Boolean literal values";
+    readonly inputSchema: RuntimeValidator<BooleanLiteralInput>;
+    readonly outputType: EvaluationType;
+    readonly metadata: ExpressionMetadata;
+    evaluate(context: TypedExpressionContext, input: BooleanLiteralInput): Promise<EvaluationResult<boolean>>;
+    validate(input: unknown): ValidationResult;
+}
+export declare class AdditionExpression extends BaseExpressionImpl<BinaryOperationInput, number> {
+    readonly name = "addition";
+    readonly category: ExpressionCategory;
+    readonly syntax = "left + right";
+    readonly description = "Addition of two numeric values";
+    readonly inputSchema: RuntimeValidator<BinaryOperationInput>;
+    readonly outputType: EvaluationType;
+    readonly metadata: ExpressionMetadata;
+    evaluate(context: TypedExpressionContext, input: BinaryOperationInput): Promise<EvaluationResult<number>>;
+    validate(input: unknown): ValidationResult;
+}
+export declare class StringConcatenationExpression extends BaseExpressionImpl<BinaryOperationInput, string> {
+    readonly name = "stringConcatenation";
+    readonly category: ExpressionCategory;
+    readonly syntax = "left + right (string concatenation)";
+    readonly description = "Concatenation of two values into a string";
+    readonly inputSchema: RuntimeValidator<BinaryOperationInput>;
+    readonly outputType: EvaluationType;
+    readonly metadata: ExpressionMetadata;
+    evaluate(context: TypedExpressionContext, input: BinaryOperationInput): Promise<EvaluationResult<string>>;
+    validate(input: unknown): ValidationResult;
+    private convertToString;
+}
+export declare class MultiplicationExpression extends BaseExpressionImpl<BinaryOperationInput, number> {
+    readonly name = "multiplication";
+    readonly category: ExpressionCategory;
+    readonly syntax = "left * right";
+    readonly description = "Multiplication of two numeric values";
+    readonly inputSchema: RuntimeValidator<BinaryOperationInput>;
+    readonly outputType: EvaluationType;
+    readonly metadata: ExpressionMetadata;
+    evaluate(context: TypedExpressionContext, input: BinaryOperationInput): Promise<EvaluationResult<number>>;
+    validate(input: unknown): ValidationResult;
+}
+export declare function createStringLiteralExpression(): StringLiteralExpression;
+export declare function createNumberLiteralExpression(): NumberLiteralExpression;
+export declare function createBooleanLiteralExpression(): BooleanLiteralExpression;
+export declare function createAdditionExpression(): AdditionExpression;
+export declare function createStringConcatenationExpression(): StringConcatenationExpression;
+export declare function createMultiplicationExpression(): MultiplicationExpression;
+export declare const specialExpressions: {
+    readonly stringLiteral: StringLiteralExpression;
+    readonly numberLiteral: NumberLiteralExpression;
+    readonly booleanLiteral: BooleanLiteralExpression;
+    readonly addition: AdditionExpression;
+    readonly stringConcatenation: StringConcatenationExpression;
+    readonly multiplication: MultiplicationExpression;
+};
+export type SpecialExpressionName = keyof typeof specialExpressions;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/expressions/type-helpers.d.ts

@@ -0,0 +1,11 @@
+export declare function isString(value: unknown): boolean;
+export declare function isNumber(value: unknown): boolean;
+export declare function isBoolean(value: unknown): boolean;
+export declare function isObject(value: unknown): boolean;
+export declare function isFunction(value: unknown): boolean;
+export declare function isArray(value: unknown): boolean;
+export declare function isElement(value: unknown): boolean;
+export declare function toNumber(value: unknown): number | null;
+export declare function isArrayLike(value: unknown): boolean;
+export declare function inferType(value: unknown): 'string' | 'number' | 'boolean' | 'element' | 'array' | 'object' | 'null' | 'undefined' | 'function' | 'unknown';
+//# sourceMappingURL=type-helpers.d.ts.map

package/dist/expressions/type-registry.d.ts

@@ -0,0 +1,57 @@
+import type { ExecutionContext, HyperScriptValueType } from '../types/base-types';
+export type JSRuntimeType = 'string' | 'number' | 'boolean' | 'null' | 'undefined' | 'object' | 'array' | 'function' | 'element' | 'element-list' | 'node-list' | 'event' | 'date' | 'regexp' | 'promise' | 'symbol' | 'unknown';
+export type CoercionFn<TFrom = unknown, TTo = unknown> = (value: TFrom, context?: ExecutionContext) => TTo | null;
+export type TypeGuardFn<T = unknown> = (value: unknown) => value is T;
+export interface ExpressionTypeDefinition<T = unknown> {
+    readonly name: string;
+    readonly hyperscriptType: HyperScriptValueType;
+    readonly tsType: string;
+    readonly isType: TypeGuardFn<T>;
+    readonly defaultValue: T | null;
+    readonly coerceFrom?: Partial<Record<string, CoercionFn<unknown, T>>>;
+    readonly description?: string;
+    readonly examples?: T[];
+}
+export interface ExpressionTypeRegistryConfig {
+    strictMode?: boolean;
+    cacheCoercions?: boolean;
+}
+export declare class ExpressionTypeRegistry {
+    private types;
+    private coercionCache;
+    private config;
+    constructor(config?: ExpressionTypeRegistryConfig);
+    register<T>(definition: ExpressionTypeDefinition<T>): void;
+    get(name: string): ExpressionTypeDefinition | undefined;
+    has(name: string): boolean;
+    getTypeNames(): string[];
+    inferType(value: unknown): string;
+    getHyperScriptType(value: unknown): HyperScriptValueType;
+    coerce<T>(value: unknown, targetType: string, context?: ExecutionContext): T | null;
+    canCoerce(value: unknown, targetType: string): boolean;
+    getCoercionInfo(sourceType: string, targetType: string): {
+        possible: boolean;
+        direct: boolean;
+        via?: string;
+    };
+    clearCache(): void;
+    getStats(): {
+        typeCount: number;
+        cacheSize: number;
+        typeNames: string[];
+    };
+    private registerBuiltinTypes;
+}
+export declare const expressionTypeRegistry: ExpressionTypeRegistry;
+export declare function inferExpressionType(value: unknown): string;
+export declare function coerceToType<T>(value: unknown, targetType: string, context?: ExecutionContext): T | null;
+export declare function canCoerceToType(value: unknown, targetType: string): boolean;
+export declare function getHyperScriptTypeName(value: unknown): HyperScriptValueType;
+export declare function coerceToString(value: unknown, context?: ExecutionContext): string;
+export declare function coerceToNumber(value: unknown, context?: ExecutionContext): number | null;
+export declare function coerceToBoolean(value: unknown, context?: ExecutionContext): boolean;
+export declare function coerceToElement(value: unknown, context?: ExecutionContext): Element | null;
+export declare function coerceToElementList(value: unknown, context?: ExecutionContext): Element[];
+export declare function coerceToArray(value: unknown, context?: ExecutionContext): unknown[];
+export declare function coerceToObject(value: unknown, context?: ExecutionContext): Record<string, unknown> | null;
+//# sourceMappingURL=type-registry.d.ts.map

package/dist/expressions/validation-helpers.d.ts

@@ -0,0 +1,15 @@
+import type { ValidationResult } from '../types/base-types';
+export declare function validateArgCount(args: unknown[], expected: number, expressionName: string, argNames?: string): string | null;
+export declare function validateMinArgs(args: unknown[], minimum: number, expressionName: string): string | null;
+export declare function validateArgIsString(args: unknown[], index: number, expressionName: string, argName?: string): string | null;
+export declare function validateArgIsNumber(args: unknown[], index: number, expressionName: string, argName?: string): string | null;
+export declare function validateArgIsElement(args: unknown[], index: number, expressionName: string, argName?: string): string | null;
+export declare function validateArgIsArrayLike(args: unknown[], index: number, expressionName: string, argName?: string): string | null;
+export declare function validateArgNotNull(args: unknown[], index: number, expressionName: string, argName?: string): string | null;
+export declare function validateSingleStringArg(args: unknown[], expressionName: string, argName: string): string | null;
+export declare function validateTwoArgs(args: unknown[], expressionName: string): string | null;
+export declare function validateNoArgs(): string | null;
+export declare function validateMaxArgs(args: unknown[], maximum: number, expressionName: string, argNames?: string): string | null;
+export declare function validateArgRange(args: unknown[], min: number, max: number, expressionName: string, argNames?: string): string | null;
+export declare function fromValidationResult(result: ValidationResult): string | null;
+//# sourceMappingURL=validation-helpers.d.ts.map

package/dist/extensions/index.d.ts

@@ -0,0 +1,3 @@
+export { TailwindExtension, tailwindExtension } from './tailwind';
+export type { TailwindOperation, TailwindStrategy, TailwindStrategyFunction } from './tailwind';
+//# sourceMappingURL=index.d.ts.map

package/dist/extensions/tailwind.d.ts

@@ -0,0 +1,22 @@
+export type TailwindOperation = 'hide' | 'show' | 'toggle';
+export type TailwindStrategy = 'twDisplay' | 'twVisibility' | 'twOpacity';
+export interface TailwindStrategyFunction {
+    (operation: TailwindOperation, element: HTMLElement): Promise<void>;
+}
+export declare class TailwindExtension {
+    private strategies;
+    private defaultStrategy;
+    constructor();
+    getStrategies(): Record<TailwindStrategy, TailwindStrategyFunction>;
+    setDefaultStrategy(strategy: TailwindStrategy): void;
+    getDefaultStrategy(): TailwindStrategy | null;
+    resetDefaultStrategy(): void;
+    executeStrategy(strategy: TailwindStrategy, operation: TailwindOperation, element: HTMLElement): Promise<void>;
+    executeWithDefaultStrategy(operation: TailwindOperation, element: HTMLElement): Promise<void>;
+    private createDisplayStrategy;
+    private createVisibilityStrategy;
+    private createOpacityStrategy;
+}
+export declare const tailwindExtension: TailwindExtension;
+export default TailwindExtension;
+//# sourceMappingURL=tailwind.d.ts.map

package/dist/features/behaviors.d.ts

@@ -0,0 +1,153 @@
+import type { ContextMetadata, EvaluationResult } from '../types/context-types';
+import type { ValidationResult, EvaluationType } from '../types/base-types';
+import type { LLMDocumentation } from '../types/command-types';
+export declare const BehaviorsInputSchema: import("../validation/lightweight-validators").RuntimeValidator<{
+    [x: string]: unknown;
+}>;
+export declare const BehaviorsOutputSchema: import("../validation/lightweight-validators").RuntimeValidator<{
+    [x: string]: unknown;
+}>;
+export type BehaviorsInput = any;
+export type BehaviorsOutput = any;
+export interface BehaviorDefinition {
+    name: string;
+    namespace?: string;
+    parameters: string[];
+    initBlock?: {
+        commands: any[];
+    };
+    eventHandlers: EventHandlerDefinition[];
+    lifecycle?: {
+        onCreate?: any[];
+        onMount?: any[];
+        onUnmount?: any[];
+        onDestroy?: any[];
+    };
+    metadata: BehaviorMetadata;
+}
+export interface EventHandlerDefinition {
+    id: string;
+    event: string;
+    eventSource?: string;
+    filter?: string;
+    commands: any[];
+    options: {
+        once?: boolean;
+        passive?: boolean;
+        capture?: boolean;
+        throttle?: number;
+        debounce?: number;
+    };
+}
+export interface BehaviorInstance {
+    id: string;
+    behaviorName: string;
+    element: HTMLElement;
+    parameters: Record<string, any>;
+    eventListeners: Map<string, EventListener>;
+    isInstalled: boolean;
+    isActive: boolean;
+    createdAt: number;
+    lastActivated: number;
+    installationCount: number;
+}
+export interface BehaviorMetadata {
+    name: string;
+    namespace?: string;
+    parameters: string[];
+    eventHandlerCount: number;
+    hasLifecycleHooks: boolean;
+    complexity: number;
+    createdAt: number;
+    installCount: number;
+    averageInstallTime: number;
+}
+export interface LifecycleEvent {
+    phase: 'create' | 'mount' | 'unmount' | 'destroy';
+    behaviorName: string;
+    instanceId: string;
+    element: HTMLElement;
+    timestamp: number;
+    data?: any;
+}
+export declare class TypedBehaviorsFeatureImplementation {
+    readonly name = "behaviorsFeature";
+    readonly category: "Frontend";
+    readonly description = "Type-safe behavior definition and installation feature with lifecycle management, event handling, and parameter validation";
+    readonly inputSchema: import("../validation/lightweight-validators").RuntimeValidator<{
+        [x: string]: unknown;
+    }>;
+    readonly outputType: EvaluationType;
+    private evaluationHistory;
+    private behaviorDefinitions;
+    private behaviorInstances;
+    private elementBehaviors;
+    private lifecycleHistory;
+    private namespaces;
+    private filterCache;
+    readonly metadata: ContextMetadata;
+    readonly documentation: LLMDocumentation;
+    initialize(input: BehaviorsInput): Promise<EvaluationResult<BehaviorsOutput>>;
+    validate(input: unknown, options?: {
+        skipEventTypeValidation?: boolean;
+    }): ValidationResult;
+    private initializeConfig;
+    private registerBehavior;
+    private installBehaviorOnTarget;
+    private createBehaviorInstance;
+    private installEventHandlers;
+    private installEventHandler;
+    private createBehaviorEventHandler;
+    private executeCommands;
+    private executeBasicCommand;
+    private executeLifecycleHook;
+    private isValidEventType;
+    private testEventFilter;
+    private calculateBehaviorComplexity;
+    private createBehaviorDefiner;
+    private createBehaviorInstaller;
+    private createBehaviorUninstaller;
+    private createBehaviorChecker;
+    private createBehaviorLister;
+    private createDefinitionGetter;
+    private createInstanceCreator;
+    private createInstanceDestroyer;
+    private createInstanceGetter;
+    private createElementInstanceGetter;
+    private createParameterUpdater;
+    private createEventHandlerAdder;
+    private createEventHandlerRemover;
+    private createLifecycleTrigger;
+    private createHandlerGetter;
+    private createParameterValidator;
+    private createParameterBinder;
+    private createDefaultsGetter;
+    private createDefaultsSetter;
+    private createLifecycleHandler;
+    private createLifecycleEventTrigger;
+    private destroyBehaviorInstance;
+    dispose(): void;
+    private trackPerformance;
+    getPerformanceMetrics(): {
+        totalInitializations: number;
+        successRate: number;
+        averageDuration: number;
+        lastEvaluationTime: number;
+        evaluationHistory: {
+            input: BehaviorsInput;
+            output?: BehaviorsOutput;
+            success: boolean;
+            duration: number;
+            timestamp: number;
+        }[];
+        totalBehaviors: number;
+        totalInstances: number;
+        totalNamespaces: number;
+        lifecycleEvents: number;
+        averageComplexity: number;
+    };
+}
+export declare function createBehaviorsFeature(): TypedBehaviorsFeatureImplementation;
+export declare function createBehaviors(behavior: Partial<BehaviorsInput['behavior']>, options?: Partial<BehaviorsInput>): Promise<EvaluationResult<BehaviorsOutput>>;
+export declare const enhancedBehaviorsImplementation: TypedBehaviorsFeatureImplementation;
+//# sourceMappingURL=behaviors.d.ts.map