@coherent.js/core 1.0.0-beta.2

package/dist/components/component-system.d.ts

@@ -0,0 +1,1138 @@
+/**
+ * Create a functional component
+ */
+export function createComponent(definition: any): Component;
+/**
+ * Create a component factory
+ */
+export function defineComponent(definition: any): {
+    (props: any): any;
+    componentName: any;
+    definition: any;
+};
+/**
+ * Register a global component
+ */
+export function registerComponent(name: any, definition: any): {
+    (props: any): any;
+    componentName: any;
+    definition: any;
+};
+/**
+ * Get a registered component
+ */
+export function getComponent(name: any): any;
+/**
+ * Get all registered components
+ */
+export function getRegisteredComponents(): Map<any, any>;
+/**
+ * Create a higher-order component
+ */
+export function createHOC(enhancer: any): (WrappedComponent: any) => {
+    (props: any): any;
+    componentName: any;
+    definition: any;
+};
+/**
+ * Mixin functionality
+ */
+export function createMixin(mixin: any): (componentDefinition: any) => any;
+/**
+ * Create lazy-evaluated properties and components
+ * Defers computation until actually needed, with optional caching
+ */
+export function lazy(factory: any, options?: {}): {
+    __isLazy: boolean;
+    __factory: any;
+    __options: {};
+    evaluate(...args: any[]): any;
+    invalidate(): /*elided*/ any;
+    isEvaluated(): boolean;
+    getCachedValue(): any;
+    map(transform: any): /*elided*/ any;
+    flatMap(transform: any): /*elided*/ any;
+    toString(): string;
+    toJSON(): any;
+};
+/**
+ * Check if value is lazy
+ */
+export function isLazy(value: any): any;
+/**
+ * Evaluate lazy values recursively in an object
+ */
+export function evaluateLazy(obj: any, ...args: any[]): any;
+/**
+ * Create lazy component
+ */
+export function lazyComponent(componentFactory: any, options?: {}): {
+    __isLazy: boolean;
+    __factory: any;
+    __options: {};
+    evaluate(...args: any[]): any;
+    invalidate(): /*elided*/ any;
+    isEvaluated(): boolean;
+    getCachedValue(): any;
+    map(transform: any): /*elided*/ any;
+    flatMap(transform: any): /*elided*/ any;
+    toString(): string;
+    toJSON(): any;
+};
+/**
+ * Create lazy import for dynamic imports
+ */
+export function lazyImport(importPromise: any, options?: {}): {
+    __isLazy: boolean;
+    __factory: any;
+    __options: {};
+    evaluate(...args: any[]): any;
+    invalidate(): /*elided*/ any;
+    isEvaluated(): boolean;
+    getCachedValue(): any;
+    map(transform: any): /*elided*/ any;
+    flatMap(transform: any): /*elided*/ any;
+    toString(): string;
+    toJSON(): any;
+};
+/**
+ * Create lazy computed property
+ */
+export function lazyComputed(computeFn: any, dependencies?: any[], options?: {}): {
+    __isLazy: boolean;
+    __factory: any;
+    __options: {};
+    evaluate(...args: any[]): any;
+    invalidate(): /*elided*/ any;
+    isEvaluated(): boolean;
+    getCachedValue(): any;
+    map(transform: any): /*elided*/ any;
+    flatMap(transform: any): /*elided*/ any;
+    toString(): string;
+    toJSON(): any;
+};
+/**
+ * Batch evaluate multiple lazy values
+ */
+export function batchEvaluate(lazyValues: any, ...args: any[]): {};
+/**
+ * Memoization utilities for caching function results and component renders
+ */
+/**
+ * Enhanced memoization with multiple caching strategies
+ */
+export function memo(fn: any, options?: {}): {
+    (...args: any[]): any;
+    cache: WeakMap<object, any> | LRUCache | TTLCache;
+    clear(): any;
+    delete(key: any): boolean;
+    has(key: any): boolean;
+    size(): any;
+    stats(): {
+        hits: number;
+        misses: number;
+        evictions: number;
+    };
+    resetStats(): void;
+    refresh(...args: any[]): any;
+};
+/**
+ * Component-specific memoization
+ */
+export function memoComponent(component: any, options?: {}): {
+    (...args: any[]): any;
+    cache: WeakMap<object, any> | LRUCache | TTLCache;
+    clear(): any;
+    delete(key: any): boolean;
+    has(key: any): boolean;
+    size(): any;
+    stats(): {
+        hits: number;
+        misses: number;
+        evictions: number;
+    };
+    resetStats(): void;
+    refresh(...args: any[]): any;
+};
+/**
+ * Async memoization with promise caching
+ */
+export function memoAsync(asyncFn: any, options?: {}): {
+    (...args: any[]): any;
+    cache: WeakMap<object, any> | LRUCache | TTLCache;
+    clear(): any;
+    delete(key: any): boolean;
+    has(key: any): boolean;
+    size(): any;
+    stats(): {
+        hits: number;
+        misses: number;
+        evictions: number;
+    };
+    resetStats(): void;
+    refresh(...args: any[]): any;
+};
+/**
+ * Higher-order function utilities for component composition and prop manipulation
+ */
+/**
+ * Enhanced withProps utility for component prop transformation and injection
+ */
+export function withProps(propsTransform: any, options?: {}): (WrappedComponent: any) => {
+    (...args: any[]): any;
+    cache: WeakMap<object, any> | LRUCache | TTLCache;
+    clear(): any;
+    delete(key: any): boolean;
+    has(key: any): boolean;
+    size(): any;
+    stats(): {
+        hits: number;
+        misses: number;
+        evictions: number;
+    };
+    resetStats(): void;
+    refresh(...args: any[]): any;
+} | {
+    (originalProps?: {}, state?: {}, context?: {}): any;
+    displayName: any;
+    __isHOC: boolean;
+    __wrappedComponent: any;
+    __transform: any;
+};
+/**
+ * Create a reusable prop transformer
+ */
+export function createPropTransformer(config: any): (WrappedComponent: any) => {
+    (...args: any[]): any;
+    cache: WeakMap<object, any> | LRUCache | TTLCache;
+    clear(): any;
+    delete(key: any): boolean;
+    has(key: any): boolean;
+    size(): any;
+    stats(): {
+        hits: number;
+        misses: number;
+        evictions: number;
+    };
+    resetStats(): void;
+    refresh(...args: any[]): any;
+} | {
+    (originalProps?: {}, state?: {}, context?: {}): any;
+    displayName: any;
+    __isHOC: boolean;
+    __wrappedComponent: any;
+    __transform: any;
+};
+/**
+ * Props debugging utility
+ */
+export function withPropsDebug(component: any, debugOptions?: {}): {
+    (...args: any[]): any;
+    cache: WeakMap<object, any> | LRUCache | TTLCache;
+    clear(): any;
+    delete(key: any): boolean;
+    has(key: any): boolean;
+    size(): any;
+    stats(): {
+        hits: number;
+        misses: number;
+        evictions: number;
+    };
+    resetStats(): void;
+    refresh(...args: any[]): any;
+} | {
+    (originalProps?: {}, state?: {}, context?: {}): any;
+    displayName: any;
+    __isHOC: boolean;
+    __wrappedComponent: any;
+    __transform: any;
+};
+/**
+ * State management utilities for component state injection and management
+ */
+/**
+ * Enhanced withState utility for component state management and injection
+ */
+export function withState(initialState?: {}, options?: {}): (WrappedComponent: any) => {
+    (props?: {}, globalState?: {}, context?: {}): any;
+    displayName: any;
+    __isHOC: boolean;
+    __hasState: boolean;
+    __stateContainer: {
+        initialized: boolean;
+        initialize(): void;
+        getState(): any;
+        setState(newState: any): boolean;
+        subscribe(listener: any): () => boolean;
+        unsubscribe(listener: any): boolean;
+        batch(batchFn: any): void;
+        destroy(): void;
+    };
+    __wrappedComponent: any;
+    cleanup(): void;
+};
+/**
+ * Create a compound state manager
+ */
+export function createStateManager(config: any): (WrappedComponent: any) => {
+    (props?: {}, globalState?: {}, context?: {}): any;
+    displayName: any;
+    __isHOC: boolean;
+    __hasState: boolean;
+    __stateContainer: {
+        initialized: boolean;
+        initialize(): void;
+        getState(): any;
+        setState(newState: any): boolean;
+        subscribe(listener: any): () => boolean;
+        unsubscribe(listener: any): boolean;
+        batch(batchFn: any): void;
+        destroy(): void;
+    };
+    __wrappedComponent: any;
+    cleanup(): void;
+};
+/**
+ * Base Component class
+ */
+export class Component {
+    constructor(definition?: {});
+    definition: {};
+    name: any;
+    props: {};
+    state: ComponentState;
+    children: any[];
+    parent: any;
+    rendered: any;
+    isMounted: boolean;
+    isDestroyed: boolean;
+    hooks: {
+        beforeCreate: any;
+        created: any;
+        beforeMount: any;
+        mounted: any;
+        beforeUpdate: any;
+        updated: any;
+        beforeDestroy: any;
+        destroyed: any;
+        errorCaptured: any;
+    };
+    methods: any;
+    computed: any;
+    computedCache: Map<any, any>;
+    watchers: any;
+    /**
+     * Initialize component
+     */
+    initialize(): void;
+    unsubscribeState: (() => boolean) | undefined;
+    /**
+     * Set up watchers for reactive data
+     */
+    setupWatchers(): void;
+    /**
+     * Initialize computed properties
+     */
+    initializeComputed(): void;
+    /**
+     * Handle state changes
+     */
+    onStateChange(): void;
+    /**
+     * Call lifecycle hook
+     */
+    callHook(hookName: any, ...args: any[]): any;
+    /**
+     * Handle component errors
+     */
+    handleError(error: any): void;
+    /**
+     * Render the component
+     */
+    render(props?: {}): any;
+    /**
+     * Process template with data
+     */
+    processTemplate(template: any, props: any, state: any): any;
+    /**
+     * Interpolate object with data
+     */
+    interpolateObject(obj: any, data: any): any;
+    /**
+     * Mount the component
+     */
+    mount(): this;
+    /**
+     * Update the component
+     */
+    update(): this;
+    /**
+     * Destroy the component
+     */
+    destroy(): this;
+    /**
+     * Get component metadata
+     */
+    getMetadata(): any;
+    /**
+     * Clone component with new props/state
+     */
+    clone(overrides?: {}): Component;
+}
+export namespace compose {
+    function combine(...components: any[]): {
+        (props: any): any;
+        componentName: any;
+        definition: any;
+    };
+    function conditional(condition: any, trueComponent: any, falseComponent?: null): {
+        (props: any): any;
+        componentName: any;
+        definition: any;
+    };
+    function loop(data: any, itemComponent: any, keyFn?: (item: any, index: any) => any): {
+        (props: any): any;
+        componentName: any;
+        definition: any;
+    };
+}
+export namespace componentUtils {
+    function getComponentTree(component: any): {
+        name: any;
+        props: any;
+        state: any;
+        children: never[];
+        metadata: any;
+    };
+    function findComponent(component: any, name: any): any;
+    function getPerformanceMetrics(component: any): {
+        renderCount: any;
+        updateCount: any;
+        createdAt: any;
+        age: number;
+    };
+    function validateDefinition(definition: any): string[];
+}
+export namespace dev {
+    function getAllComponents(): {
+        name: any;
+        factory: any;
+        definition: any;
+    }[];
+    function clearRegistry(): void;
+    function getRegistryStats(): {
+        totalComponents: number;
+        components: any[];
+    };
+}
+export namespace lazyUtils {
+    export function chain(...transformations: any[]): {
+        __isLazy: boolean;
+        __factory: any;
+        __options: {};
+        evaluate(...args: any[]): any;
+        invalidate(): /*elided*/ any;
+        isEvaluated(): boolean;
+        getCachedValue(): any;
+        map(transform: any): /*elided*/ any;
+        flatMap(transform: any): /*elided*/ any;
+        toString(): string;
+        toJSON(): any;
+    };
+    export function conditional_1(condition: any, trueFactory: any, falseFactory: any): {
+        __isLazy: boolean;
+        __factory: any;
+        __options: {};
+        evaluate(...args: any[]): any;
+        invalidate(): /*elided*/ any;
+        isEvaluated(): boolean;
+        getCachedValue(): any;
+        map(transform: any): /*elided*/ any;
+        flatMap(transform: any): /*elided*/ any;
+        toString(): string;
+        toJSON(): any;
+    };
+    export { conditional_1 as conditional };
+    export function memoize(fn: any, keyFn?: (...args: any[]) => string): {
+        __isLazy: boolean;
+        __factory: any;
+        __options: {};
+        evaluate(...args: any[]): any;
+        invalidate(): /*elided*/ any;
+        isEvaluated(): boolean;
+        getCachedValue(): any;
+        map(transform: any): /*elided*/ any;
+        flatMap(transform: any): /*elided*/ any;
+        toString(): string;
+        toJSON(): any;
+    };
+    export function async(asyncFn: any, options?: {}): {
+        __isLazy: boolean;
+        __factory: any;
+        __options: {};
+        evaluate(...args: any[]): any;
+        invalidate(): /*elided*/ any;
+        isEvaluated(): boolean;
+        getCachedValue(): any;
+        map(transform: any): /*elided*/ any;
+        flatMap(transform: any): /*elided*/ any;
+        toString(): string;
+        toJSON(): any;
+    };
+    export function array(items?: any[]): {
+        __isLazy: boolean;
+        __factory: any;
+        __options: {};
+        evaluate(...args: any[]): any;
+        invalidate(): /*elided*/ any;
+        isEvaluated(): boolean;
+        getCachedValue(): any;
+        map(transform: any): /*elided*/ any;
+        flatMap(transform: any): /*elided*/ any;
+        toString(): string;
+        toJSON(): any;
+    };
+    export function object(obj?: {}): {
+        __isLazy: boolean;
+        __factory: any;
+        __options: {};
+        evaluate(...args: any[]): any;
+        invalidate(): /*elided*/ any;
+        isEvaluated(): boolean;
+        getCachedValue(): any;
+        map(transform: any): /*elided*/ any;
+        flatMap(transform: any): /*elided*/ any;
+        toString(): string;
+        toJSON(): any;
+    };
+}
+export namespace memoUtils {
+    export function auto(fn: any, dependencies?: any[]): (...args: any[]) => any;
+    export function sized(fn: any, maxSize?: number): {
+        (...args: any[]): any;
+        cache: WeakMap<object, any> | LRUCache | TTLCache;
+        clear(): any;
+        delete(key: any): boolean;
+        has(key: any): boolean;
+        size(): any;
+        stats(): {
+            hits: number;
+            misses: number;
+            evictions: number;
+        };
+        resetStats(): void;
+        refresh(...args: any[]): any;
+    };
+    export function timed(fn: any, ttl?: number): {
+        (...args: any[]): any;
+        cache: WeakMap<object, any> | LRUCache | TTLCache;
+        clear(): any;
+        delete(key: any): boolean;
+        has(key: any): boolean;
+        size(): any;
+        stats(): {
+            hits: number;
+            misses: number;
+            evictions: number;
+        };
+        resetStats(): void;
+        refresh(...args: any[]): any;
+    };
+    export function weak(fn: any): {
+        (...args: any[]): any;
+        cache: WeakMap<object, any> | LRUCache | TTLCache;
+        clear(): any;
+        delete(key: any): boolean;
+        has(key: any): boolean;
+        size(): any;
+        stats(): {
+            hits: number;
+            misses: number;
+            evictions: number;
+        };
+        resetStats(): void;
+        refresh(...args: any[]): any;
+    };
+    export function variants(fn: any, configs: any): {};
+    export function conditional_2(fn: any, shouldMemo?: () => boolean): (...args: any[]) => any;
+    export { conditional_2 as conditional };
+    export function custom(fn: any, storage: any): (...args: any[]) => any;
+}
+export namespace withPropsUtils {
+    export function _static(staticProps: any): (WrappedComponent: any) => {
+        (...args: any[]): any;
+        cache: WeakMap<object, any> | LRUCache | TTLCache;
+        clear(): any;
+        delete(key: any): boolean;
+        has(key: any): boolean;
+        size(): any;
+        stats(): {
+            hits: number;
+            misses: number;
+            evictions: number;
+        };
+        resetStats(): void;
+        refresh(...args: any[]): any;
+    } | {
+        (originalProps?: {}, state?: {}, context?: {}): any;
+        displayName: any;
+        __isHOC: boolean;
+        __wrappedComponent: any;
+        __transform: any;
+    };
+    export { _static as static };
+    export function conditional_3(condition: any, trueProps: any, falseProps?: {}): (WrappedComponent: any) => {
+        (...args: any[]): any;
+        cache: WeakMap<object, any> | LRUCache | TTLCache;
+        clear(): any;
+        delete(key: any): boolean;
+        has(key: any): boolean;
+        size(): any;
+        stats(): {
+            hits: number;
+            misses: number;
+            evictions: number;
+        };
+        resetStats(): void;
+        refresh(...args: any[]): any;
+    } | {
+        (originalProps?: {}, state?: {}, context?: {}): any;
+        displayName: any;
+        __isHOC: boolean;
+        __wrappedComponent: any;
+        __transform: any;
+    };
+    export { conditional_3 as conditional };
+    export function map(mapping: any): (WrappedComponent: any) => {
+        (...args: any[]): any;
+        cache: WeakMap<object, any> | LRUCache | TTLCache;
+        clear(): any;
+        delete(key: any): boolean;
+        has(key: any): boolean;
+        size(): any;
+        stats(): {
+            hits: number;
+            misses: number;
+            evictions: number;
+        };
+        resetStats(): void;
+        refresh(...args: any[]): any;
+    } | {
+        (originalProps?: {}, state?: {}, context?: {}): any;
+        displayName: any;
+        __isHOC: boolean;
+        __wrappedComponent: any;
+        __transform: any;
+    };
+    export function pick(keys: any): (WrappedComponent: any) => {
+        (...args: any[]): any;
+        cache: WeakMap<object, any> | LRUCache | TTLCache;
+        clear(): any;
+        delete(key: any): boolean;
+        has(key: any): boolean;
+        size(): any;
+        stats(): {
+            hits: number;
+            misses: number;
+            evictions: number;
+        };
+        resetStats(): void;
+        refresh(...args: any[]): any;
+    } | {
+        (originalProps?: {}, state?: {}, context?: {}): any;
+        displayName: any;
+        __isHOC: boolean;
+        __wrappedComponent: any;
+        __transform: any;
+    };
+    export function omit(keys: any): (WrappedComponent: any) => {
+        (...args: any[]): any;
+        cache: WeakMap<object, any> | LRUCache | TTLCache;
+        clear(): any;
+        delete(key: any): boolean;
+        has(key: any): boolean;
+        size(): any;
+        stats(): {
+            hits: number;
+            misses: number;
+            evictions: number;
+        };
+        resetStats(): void;
+        refresh(...args: any[]): any;
+    } | {
+        (originalProps?: {}, state?: {}, context?: {}): any;
+        displayName: any;
+        __isHOC: boolean;
+        __wrappedComponent: any;
+        __transform: any;
+    };
+    export function defaults(defaultProps: any): (WrappedComponent: any) => {
+        (...args: any[]): any;
+        cache: WeakMap<object, any> | LRUCache | TTLCache;
+        clear(): any;
+        delete(key: any): boolean;
+        has(key: any): boolean;
+        size(): any;
+        stats(): {
+            hits: number;
+            misses: number;
+            evictions: number;
+        };
+        resetStats(): void;
+        refresh(...args: any[]): any;
+    } | {
+        (originalProps?: {}, state?: {}, context?: {}): any;
+        displayName: any;
+        __isHOC: boolean;
+        __wrappedComponent: any;
+        __transform: any;
+    };
+    export function validated(transform: any, validator: any): (WrappedComponent: any) => {
+        (...args: any[]): any;
+        cache: WeakMap<object, any> | LRUCache | TTLCache;
+        clear(): any;
+        delete(key: any): boolean;
+        has(key: any): boolean;
+        size(): any;
+        stats(): {
+            hits: number;
+            misses: number;
+            evictions: number;
+        };
+        resetStats(): void;
+        refresh(...args: any[]): any;
+    } | {
+        (originalProps?: {}, state?: {}, context?: {}): any;
+        displayName: any;
+        __isHOC: boolean;
+        __wrappedComponent: any;
+        __transform: any;
+    };
+    export function async_1(asyncTransform: any, loadingProps?: {}): (WrappedComponent: any) => {
+        (...args: any[]): any;
+        cache: WeakMap<object, any> | LRUCache | TTLCache;
+        clear(): any;
+        delete(key: any): boolean;
+        has(key: any): boolean;
+        size(): any;
+        stats(): {
+            hits: number;
+            misses: number;
+            evictions: number;
+        };
+        resetStats(): void;
+        refresh(...args: any[]): any;
+    } | {
+        (originalProps?: {}, state?: {}, context?: {}): any;
+        displayName: any;
+        __isHOC: boolean;
+        __wrappedComponent: any;
+        __transform: any;
+    };
+    export { async_1 as async };
+    export function computed(computedProps: any): (WrappedComponent: any) => {
+        (...args: any[]): any;
+        cache: WeakMap<object, any> | LRUCache | TTLCache;
+        clear(): any;
+        delete(key: any): boolean;
+        has(key: any): boolean;
+        size(): any;
+        stats(): {
+            hits: number;
+            misses: number;
+            evictions: number;
+        };
+        resetStats(): void;
+        refresh(...args: any[]): any;
+    } | {
+        (originalProps?: {}, state?: {}, context?: {}): any;
+        displayName: any;
+        __isHOC: boolean;
+        __wrappedComponent: any;
+        __transform: any;
+    };
+    export function withContext(contextKeys: any): (WrappedComponent: any) => {
+        (...args: any[]): any;
+        cache: WeakMap<object, any> | LRUCache | TTLCache;
+        clear(): any;
+        delete(key: any): boolean;
+        has(key: any): boolean;
+        size(): any;
+        stats(): {
+            hits: number;
+            misses: number;
+            evictions: number;
+        };
+        resetStats(): void;
+        refresh(...args: any[]): any;
+    } | {
+        (originalProps?: {}, state?: {}, context?: {}): any;
+        displayName: any;
+        __isHOC: boolean;
+        __wrappedComponent: any;
+        __transform: any;
+    };
+    export function withState(stateMapping: any): (WrappedComponent: any) => {
+        (...args: any[]): any;
+        cache: WeakMap<object, any> | LRUCache | TTLCache;
+        clear(): any;
+        delete(key: any): boolean;
+        has(key: any): boolean;
+        size(): any;
+        stats(): {
+            hits: number;
+            misses: number;
+            evictions: number;
+        };
+        resetStats(): void;
+        refresh(...args: any[]): any;
+    } | {
+        (originalProps?: {}, state?: {}, context?: {}): any;
+        displayName: any;
+        __isHOC: boolean;
+        __wrappedComponent: any;
+        __transform: any;
+    };
+    export function memoized(transform: any, memoOptions?: {}): (WrappedComponent: any) => {
+        (...args: any[]): any;
+        cache: WeakMap<object, any> | LRUCache | TTLCache;
+        clear(): any;
+        delete(key: any): boolean;
+        has(key: any): boolean;
+        size(): any;
+        stats(): {
+            hits: number;
+            misses: number;
+            evictions: number;
+        };
+        resetStats(): void;
+        refresh(...args: any[]): any;
+    } | {
+        (originalProps?: {}, state?: {}, context?: {}): any;
+        displayName: any;
+        __isHOC: boolean;
+        __wrappedComponent: any;
+        __transform: any;
+    };
+    export function timed_1(transform: any, name?: string): (WrappedComponent: any) => {
+        (...args: any[]): any;
+        cache: WeakMap<object, any> | LRUCache | TTLCache;
+        clear(): any;
+        delete(key: any): boolean;
+        has(key: any): boolean;
+        size(): any;
+        stats(): {
+            hits: number;
+            misses: number;
+            evictions: number;
+        };
+        resetStats(): void;
+        refresh(...args: any[]): any;
+    } | {
+        (originalProps?: {}, state?: {}, context?: {}): any;
+        displayName: any;
+        __isHOC: boolean;
+        __wrappedComponent: any;
+        __transform: any;
+    };
+    export { timed_1 as timed };
+    export function chain_1(...transforms: any[]): (WrappedComponent: any) => {
+        (...args: any[]): any;
+        cache: WeakMap<object, any> | LRUCache | TTLCache;
+        clear(): any;
+        delete(key: any): boolean;
+        has(key: any): boolean;
+        size(): any;
+        stats(): {
+            hits: number;
+            misses: number;
+            evictions: number;
+        };
+        resetStats(): void;
+        refresh(...args: any[]): any;
+    } | {
+        (originalProps?: {}, state?: {}, context?: {}): any;
+        displayName: any;
+        __isHOC: boolean;
+        __wrappedComponent: any;
+        __transform: any;
+    };
+    export { chain_1 as chain };
+}
+export namespace withStateUtils {
+    export function local(initialState: any): (WrappedComponent: any) => {
+        (props?: {}, globalState?: {}, context?: {}): any;
+        displayName: any;
+        __isHOC: boolean;
+        __hasState: boolean;
+        __stateContainer: {
+            initialized: boolean;
+            initialize(): void;
+            getState(): any;
+            setState(newState: any): boolean;
+            subscribe(listener: any): () => boolean;
+            unsubscribe(listener: any): boolean;
+            batch(batchFn: any): void;
+            destroy(): void;
+        };
+        __wrappedComponent: any;
+        cleanup(): void;
+    };
+    export function persistent(initialState: any, key: any): (WrappedComponent: any) => {
+        (props?: {}, globalState?: {}, context?: {}): any;
+        displayName: any;
+        __isHOC: boolean;
+        __hasState: boolean;
+        __stateContainer: {
+            initialized: boolean;
+            initialize(): void;
+            getState(): any;
+            setState(newState: any): boolean;
+            subscribe(listener: any): () => boolean;
+            unsubscribe(listener: any): boolean;
+            batch(batchFn: any): void;
+            destroy(): void;
+        };
+        __wrappedComponent: any;
+        cleanup(): void;
+    };
+    export function reducer(initialState: any, reducer: any, actions?: {}): (WrappedComponent: any) => {
+        (props?: {}, globalState?: {}, context?: {}): any;
+        displayName: any;
+        __isHOC: boolean;
+        __hasState: boolean;
+        __stateContainer: {
+            initialized: boolean;
+            initialize(): void;
+            getState(): any;
+            setState(newState: any): boolean;
+            subscribe(listener: any): () => boolean;
+            unsubscribe(listener: any): boolean;
+            batch(batchFn: any): void;
+            destroy(): void;
+        };
+        __wrappedComponent: any;
+        cleanup(): void;
+    };
+    export function async_2(initialState: any, asyncActions?: {}): (WrappedComponent: any) => {
+        (props?: {}, globalState?: {}, context?: {}): any;
+        displayName: any;
+        __isHOC: boolean;
+        __hasState: boolean;
+        __stateContainer: {
+            initialized: boolean;
+            initialize(): void;
+            getState(): any;
+            setState(newState: any): boolean;
+            subscribe(listener: any): () => boolean;
+            unsubscribe(listener: any): boolean;
+            batch(batchFn: any): void;
+            destroy(): void;
+        };
+        __wrappedComponent: any;
+        cleanup(): void;
+    };
+    export { async_2 as async };
+    export function validated_1(initialState: any, validator: any): (WrappedComponent: any) => {
+        (props?: {}, globalState?: {}, context?: {}): any;
+        displayName: any;
+        __isHOC: boolean;
+        __hasState: boolean;
+        __stateContainer: {
+            initialized: boolean;
+            initialize(): void;
+            getState(): any;
+            setState(newState: any): boolean;
+            subscribe(listener: any): () => boolean;
+            unsubscribe(listener: any): boolean;
+            batch(batchFn: any): void;
+            destroy(): void;
+        };
+        __wrappedComponent: any;
+        cleanup(): void;
+    };
+    export { validated_1 as validated };
+    export function shared(initialState: any, sharedKey: any): (WrappedComponent: any) => {
+        (props: any, globalState: any, context: any): any;
+        displayName: string;
+    };
+    export function form(initialFormState: any): (WrappedComponent: any) => {
+        (props?: {}, globalState?: {}, context?: {}): any;
+        displayName: any;
+        __isHOC: boolean;
+        __hasState: boolean;
+        __stateContainer: {
+            initialized: boolean;
+            initialize(): void;
+            getState(): any;
+            setState(newState: any): boolean;
+            subscribe(listener: any): () => boolean;
+            unsubscribe(listener: any): boolean;
+            batch(batchFn: any): void;
+            destroy(): void;
+        };
+        __wrappedComponent: any;
+        cleanup(): void;
+    };
+    export function withLoading(initialState: any): Promise<(WrappedComponent: any) => {
+        (props?: {}, globalState?: {}, context?: {}): any;
+        displayName: any;
+        __isHOC: boolean;
+        __hasState: boolean;
+        __stateContainer: {
+            initialized: boolean;
+            initialize(): void;
+            getState(): any;
+            setState(newState: any): boolean;
+            subscribe(listener: any): () => boolean;
+            unsubscribe(listener: any): boolean;
+            batch(batchFn: any): void;
+            destroy(): void;
+        };
+        __wrappedComponent: any;
+        cleanup(): void;
+    }>;
+    export function withHistory(initialState: any, maxHistory?: number): (WrappedComponent: any) => {
+        (props?: {}, globalState?: {}, context?: {}): any;
+        displayName: any;
+        __isHOC: boolean;
+        __hasState: boolean;
+        __stateContainer: {
+            initialized: boolean;
+            initialize(): void;
+            getState(): any;
+            setState(newState: any): boolean;
+            subscribe(listener: any): () => boolean;
+            unsubscribe(listener: any): boolean;
+            batch(batchFn: any): void;
+            destroy(): void;
+        };
+        __wrappedComponent: any;
+        cleanup(): void;
+    };
+    export function computed_1(initialState: any, computedProps: any): (WrappedComponent: any) => {
+        (props?: {}, globalState?: {}, context?: {}): any;
+        displayName: any;
+        __isHOC: boolean;
+        __hasState: boolean;
+        __stateContainer: {
+            initialized: boolean;
+            initialize(): void;
+            getState(): any;
+            setState(newState: any): boolean;
+            subscribe(listener: any): () => boolean;
+            unsubscribe(listener: any): boolean;
+            batch(batchFn: any): void;
+            destroy(): void;
+        };
+        __wrappedComponent: any;
+        cleanup(): void;
+    };
+    export { computed_1 as computed };
+}
+declare namespace _default {
+    export { Component };
+    export { createComponent };
+    export { defineComponent };
+    export { registerComponent };
+    export { getComponent };
+    export { getRegisteredComponents };
+    export { createHOC };
+    export { createMixin };
+    export { compose };
+    export { componentUtils };
+    export { dev };
+    export { lazy };
+    export { lazyUtils };
+    export { evaluateLazy };
+    export { evaluateWithTimeout };
+    export { batchEvaluate };
+    export { hashDependencies };
+    export { memo };
+    export { memoUtils };
+    export { withProps };
+    export { withPropsUtils };
+    export { withPropsDebug };
+    export { withState };
+    export { createStateManager };
+    export { getComponentName };
+    export { withStateUtils };
+}
+export default _default;
+/**
+ * LRU Cache implementation
+ */
+declare class LRUCache {
+    constructor(maxSize?: number, options?: {});
+    maxSize: number;
+    cache: Map<any, any>;
+    onEvict: any;
+    get(key: any): any;
+    set(key: any, value: any): void;
+    has(key: any): boolean;
+    delete(key: any): boolean;
+    clear(): void;
+    get size(): number;
+}
+/**
+ * TTL Cache implementation
+ */
+declare class TTLCache {
+    constructor(ttl: any, options?: {});
+    ttl: any;
+    cache: Map<any, any>;
+    timers: Map<any, any>;
+    onEvict: any;
+    get(key: any): any;
+    set(key: any, value: any): void;
+    has(key: any): boolean;
+    delete(key: any): boolean;
+    clear(): void;
+    get size(): number;
+}
+/**
+ * Component state management class
+ *
+ * @class ComponentState
+ * @description Manages component state with reactive updates and listener notifications.
+ * Provides immutable state updates with change detection.
+ *
+ * @param {Object} [initialState={}] - Initial state object
+ *
+ * @example
+ * const state = new ComponentState({ count: 0 });
+ * state.set({ count: 1 });
+ * const count = state.get('count'); // 1
+ */
+declare class ComponentState {
+    constructor(initialState?: {});
+    state: {};
+    listeners: Set<any>;
+    isUpdating: boolean;
+    /**
+     * Get state value by key or entire state
+     *
+     * @param {string} [key] - State key to retrieve
+     * @returns {*} State value or entire state object
+     */
+    get(key?: string): any;
+    /**
+     * Update state with new values
+     *
+     * @param {Object} updates - State updates to apply
+     * @returns {ComponentState} This instance for chaining
+     */
+    set(updates: Object): ComponentState;
+    subscribe(listener: any): () => boolean;
+    notifyListeners(oldState: any, newState: any): void;
+}
+/**
+ * Helper function to evaluate with timeout
+ */
+declare function evaluateWithTimeout(factory: any, timeout: any, args: any, fallback: any): Promise<any>;
+/**
+ * Helper function to hash dependencies
+ */
+declare function hashDependencies(dependencies: any): any;
+declare function getComponentName(component: any): any;
+//# sourceMappingURL=component-system.d.ts.map