@servlyadmin/runtime-core 0.1.8 → 0.1.9

package/dist/index.d.cts

@@ -1,1842 +0,0 @@
-/**
- * Servly Runtime Core Types
- * Framework-agnostic type definitions for Layout JSON rendering
- */
-/**
- * Configuration options for an element
- */
-interface ElementConfig {
-    /** HTML tag override */
-    tag?: string;
-    /** Static text content */
-    text?: string;
-    /** Dynamic text with template bindings */
-    dynamicText?: string;
-    /** CSS class name */
-    className?: string;
-    /** Additional CSS class names */
-    classNames?: string;
-    /** Dynamic class name with template bindings */
-    dynamicClassName?: string;
-    /** CSS variables to apply */
-    cssVariables?: Record<string, string>;
-    /** Element ID */
-    id?: string;
-    /** Image source */
-    src?: string;
-    /** Dynamic image source */
-    dynamicSrc?: string;
-    /** Dynamic href */
-    dynamicHref?: string;
-    /** Dynamic value */
-    dynamicValue?: string;
-    /** Alt text for images */
-    alt?: string;
-    /** Link href */
-    href?: string;
-    /** Link target */
-    target?: string;
-    /** Input placeholder */
-    placeholder?: string;
-    /** Input type */
-    type?: string;
-    /** Input name */
-    name?: string;
-    /** Input value */
-    value?: string;
-    /** Disabled state */
-    disabled?: boolean;
-    /** Required state */
-    required?: boolean;
-    /** Read-only state */
-    readOnly?: boolean;
-    /** Inline styles */
-    style?: Record<string, any>;
-    /** Input bindings for props */
-    bindings?: {
-        inputs?: Record<string, {
-            source: 'static' | 'props' | 'state' | 'parent' | 'function';
-            value?: any;
-            path?: string;
-            binding?: any;
-        }>;
-    };
-    /** Reference to another component (for componentView elements) */
-    componentViewRef?: string;
-    /** Version specifier for the referenced component */
-    componentViewVersion?: string;
-    /** Props to pass to the referenced component */
-    componentViewProps?: Record<string, any>;
-    /** Blueprint ID for renderDynamicList */
-    blueprint?: string;
-    /** Blueprint version specifier */
-    blueprintVersion?: string;
-    /** Slot name for slot elements */
-    slotName?: string;
-    /** Fallback content for empty slots */
-    fallback?: any[];
-    /** Data attributes */
-    [key: `data-${string}`]: string | undefined;
-    /** Aria attributes */
-    [key: `aria-${string}`]: string | undefined;
-}
-/**
- * A single element in the Layout JSON tree
- */
-interface LayoutElement {
-    /** Unique element identifier */
-    i: string;
-    /** Component type (container, text, button, etc.) */
-    componentId: string;
-    /** Parent element ID (null for root elements) */
-    parent?: string | null;
-    /** Element configuration */
-    configuration?: ElementConfig;
-    /** Inline styles */
-    style?: Record<string, any>;
-    /** CSS class name */
-    className?: string;
-    /** Whether this is a group/container */
-    isGroup?: boolean;
-    /** Child element IDs */
-    children?: string[];
-    /** Element name for debugging */
-    name?: string;
-    /** Slot name (for slot elements that can receive external content) */
-    slotName?: string;
-}
-/**
- * Context for resolving template bindings
- */
-interface BindingContext {
-    /** Props passed to the component */
-    props: Record<string, any>;
-    /** Component state */
-    state?: Record<string, any>;
-    /** Additional context data */
-    context?: Record<string, any>;
-}
-/**
- * Registry of available components for dependency resolution
- */
-interface ComponentRegistry {
-    /** Get component by ID and optional version */
-    get(id: string, version?: string): BundledComponent | undefined;
-    /** Check if component exists */
-    has(id: string, version?: string): boolean;
-    /** Register a component */
-    set(id: string, version: string, component: BundledComponent): void;
-}
-/**
- * Options for rendering a component
- */
-interface RenderOptions {
-    /** Container element to render into */
-    container: HTMLElement;
-    /** Layout elements to render */
-    elements: LayoutElement[];
-    /** Binding context for template resolution */
-    context: BindingContext;
-    /** Event handlers keyed by element ID then event name */
-    eventHandlers?: Record<string, Record<string, (e: Event) => void>>;
-    /** Registry of components for resolving componentViewRef and blueprints */
-    componentRegistry?: ComponentRegistry;
-    /** Callback when a dependency needs to be loaded */
-    onDependencyNeeded?: (id: string, version?: string) => Promise<BundledComponent | undefined>;
-    /** Callback when rendering a referenced component */
-    onComponentRender?: (id: string, container: HTMLElement) => void;
-    /** Map of view ID to view data for isComponentView resolution */
-    views?: Map<string, {
-        id: string;
-        layout: LayoutElement[];
-        props?: any;
-    }>;
-    /** Enable built-in state management for Servly plugin actions */
-    enableStateManager?: boolean;
-    /** Initial state for the state manager */
-    initialState?: Record<string, any>;
-    /** Callback when state changes */
-    onStateChange?: (event: {
-        key: string;
-        value: any;
-        previousValue: any;
-    }) => void;
-    /** Custom plugin executors for event system */
-    pluginExecutors?: Record<string, (action: any, context: any) => any>;
-    /** Callback when navigation is requested */
-    onNavigate?: (url: string, options?: {
-        replace?: boolean;
-        state?: any;
-    }) => void;
-    /** Callback for external API calls */
-    onApiCall?: (config: any) => Promise<any>;
-}
-/**
- * Result of a render operation
- */
-interface RenderResult {
-    /** Root DOM element created */
-    rootElement: HTMLElement | null;
-    /** Update the rendered component with new context */
-    update: (context: BindingContext) => void;
-    /** Destroy the rendered component and clean up */
-    destroy: () => void;
-}
-/**
- * Prop definition for a component
- */
-interface PropDefinition {
-    /** Prop name */
-    name: string;
-    /** Prop type */
-    type: 'string' | 'number' | 'boolean' | 'object' | 'array' | 'function';
-    /** Whether the prop is required */
-    required: boolean;
-    /** Default value if not provided */
-    defaultValue?: any;
-    /** Description for documentation */
-    description?: string;
-}
-/**
- * Test case assertion
- */
-interface Assertion$1 {
-    /** CSS selector to find element */
-    selector: string;
-    /** Property to check */
-    property: 'text' | 'attribute' | 'style' | 'exists' | 'class';
-    /** Attribute name (for attribute checks) */
-    attributeName?: string;
-    /** Style property name (for style checks) */
-    styleName?: string;
-    /** Expected value */
-    expected: any;
-}
-/**
- * Test case for component validation
- */
-interface TestCase$1 {
-    /** Unique test case ID */
-    id: string;
-    /** Test case name */
-    name: string;
-    /** Props to use for this test */
-    props: Record<string, any>;
-    /** Assertions to validate */
-    assertions?: Assertion$1[];
-}
-/**
- * Type of component dependency
- */
-type DependencyType = 'blueprint' | 'viewRef' | 'slot';
-/**
- * Single dependency entry in manifest
- */
-interface DependencyEntry {
-    /** Requested version specifier (e.g., "^1.0.0") */
-    version: string;
-    /** Actual resolved version (e.g., "1.2.3") */
-    resolved: string;
-    /** Type of dependency */
-    type: DependencyType;
-    /** Parent dependency ID (for nested deps) */
-    via?: string;
-    /** If true, component works without this dependency */
-    optional?: boolean;
-}
-/**
- * Manifest of all component dependencies
- */
-interface DependencyManifest {
-    [componentId: string]: DependencyEntry;
-}
-/**
- * Bundled component data (minimal for bundle)
- */
-interface BundledComponent {
-    /** Layout JSON elements */
-    layout: LayoutElement[];
-    /** Props interface definition */
-    propsInterface?: PropDefinition[];
-}
-/**
- * Bundle of all dependencies
- * Key format: "componentId@version"
- */
-interface ComponentBundle {
-    [componentIdAtVersion: string]: BundledComponent;
-}
-/**
- * View data structure (matches application views)
- */
-interface ViewData {
-    /** View ID */
-    id: string;
-    /** View name */
-    name?: string;
-    /** Layout JSON elements */
-    layout: LayoutElement[];
-    /** Props interface definition */
-    propsInterface?: PropDefinition[];
-    /** Whether this is the main/entry view */
-    isMain?: boolean;
-}
-/**
- * Component data from registry
- */
-interface ComponentData {
-    /** Component ID */
-    id: string;
-    /** Component name */
-    name: string;
-    /** Component description */
-    description?: string;
-    /** Component version */
-    version: string;
-    /** Layout JSON elements */
-    layout: LayoutElement[];
-    /** Props interface definition */
-    propsInterface?: PropDefinition[];
-    /** Test cases for validation */
-    testCases?: TestCase$1[];
-    /** CSS variables used */
-    cssVariables?: Record<string, string>;
-    /** Component tags for search */
-    tags?: string[];
-    /** Created timestamp */
-    createdAt?: string;
-    /** Updated timestamp */
-    updatedAt?: string;
-    /** Dependency manifest - lists all required components */
-    dependencies?: DependencyManifest;
-    /** Bundled dependencies - included component data */
-    bundle?: ComponentBundle;
-    /** All views needed to render this component (returned by API) */
-    views?: ViewData[];
-}
-/**
- * Cache entry for component data
- */
-interface CacheEntry {
-    /** Cached component data */
-    data: ComponentData;
-    /** Timestamp when cached */
-    timestamp: number;
-    /** Version of cached component */
-    version: string;
-    /** Number of times accessed */
-    accessCount: number;
-    /** Last access timestamp */
-    lastAccessed: number;
-}
-/**
- * Cache configuration
- */
-interface CacheConfig {
-    /** Maximum number of entries in cache */
-    maxEntries?: number;
-    /** Time-to-live in milliseconds */
-    ttl?: number;
-    /** Storage key prefix for localStorage */
-    storageKeyPrefix?: string;
-}
-/**
- * Cache strategy type
- */
-type CacheStrategy = 'memory' | 'localStorage' | 'none';
-/**
- * Retry configuration for failed fetches
- */
-interface RetryConfig {
-    /** Maximum number of retries */
-    maxRetries?: number;
-    /** Initial delay in ms */
-    initialDelay?: number;
-    /** Maximum delay in ms */
-    maxDelay?: number;
-    /** Backoff multiplier */
-    backoffMultiplier?: number;
-}
-/**
- * Bundle loading strategy
- */
-type BundleStrategy = 'eager' | 'lazy' | 'none';
-/**
- * Options for fetching a component
- */
-interface FetchOptions {
-    /** Version specifier */
-    version?: string;
-    /** API key for authentication */
-    apiKey?: string;
-    /** Cache strategy */
-    cacheStrategy?: CacheStrategy;
-    /** Cache configuration */
-    cacheConfig?: CacheConfig;
-    /** Retry configuration */
-    retryConfig?: Partial<RetryConfig>;
-    /** Skip cache and force fetch */
-    forceRefresh?: boolean;
-    /** Abort signal for cancellation */
-    signal?: AbortSignal;
-    /** How to handle dependencies: eager (bundle all), lazy (fetch on demand), none */
-    bundleStrategy?: BundleStrategy;
-    /** Include bundled dependencies in response */
-    includeBundle?: boolean;
-    /** Maximum bundle size in bytes before switching to lazy */
-    maxBundleSize?: number;
-    /** Include all views needed to render this component (default: true) */
-    includeViews?: boolean;
-}
-/**
- * Result of a fetch operation
- */
-interface FetchResult {
-    /** Fetched component data */
-    data: ComponentData;
-    /** Whether data came from cache */
-    fromCache: boolean;
-    /** Resolved version */
-    version: string;
-    /** Pre-built component registry from bundle */
-    registry?: ComponentRegistry;
-    /** List of dependencies that need lazy loading */
-    pendingDependencies?: Array<{
-        id: string;
-        version: string;
-    }>;
-    /** Views map built from API response (ready for render()) */
-    views?: Map<string, {
-        id: string;
-        layout: LayoutElement[];
-        props?: any;
-    }>;
-}
-/**
- * Result of a single assertion
- */
-interface AssertionResult$1 {
-    /** Whether assertion passed */
-    passed: boolean;
-    /** The assertion that was checked */
-    assertion: Assertion$1;
-    /** Actual value found */
-    actual?: any;
-    /** Error message if failed */
-    error?: string;
-}
-/**
- * Result of running a test case
- */
-interface TestCaseResult {
-    /** Test case ID */
-    id: string;
-    /** Test case name */
-    name: string;
-    /** Whether all assertions passed */
-    passed: boolean;
-    /** Individual assertion results */
-    assertions: AssertionResult$1[];
-    /** Execution time in ms */
-    duration: number;
-}
-/**
- * Summary of all test results
- */
-interface TestSummary$1 {
-    /** Total number of tests */
-    total: number;
-    /** Number of passed tests */
-    passed: number;
-    /** Number of failed tests */
-    failed: number;
-    /** Individual test results */
-    results: TestCaseResult[];
-    /** Total execution time in ms */
-    duration: number;
-}
-
-/**
- * Vanilla DOM Renderer
- * Renders Layout JSON to native DOM elements
- * Supports component dependencies via componentViewRef, isComponentView, and blueprint
- *
- * This renderer is designed to produce output consistent with RenderElements.tsx
- * in the builder, enabling preview and production rendering to match.
- */
-
-/**
- * Render Layout JSON to DOM
- */
-declare function render(options: RenderOptions): RenderResult;
-/**
- * Render a dynamic list using a blueprint component
- * This is called by event handlers that use renderDynamicList
- */
-declare function renderDynamicList(options: {
-    /** Target container element or selector */
-    targetContainer: HTMLElement | string;
-    /** Blueprint component ID */
-    blueprint: string;
-    /** Blueprint version (optional) */
-    blueprintVersion?: string;
-    /** Data array to render */
-    data: any[];
-    /** How to render: 'renderInto' clears container, 'append' adds to end */
-    renderType?: 'renderInto' | 'append' | 'prepend';
-    /** Item variable name in template (default: 'item') */
-    itemKey?: string;
-    /** Index variable name in template (default: 'index') */
-    indexKey?: string;
-    /** Component registry for blueprint lookup */
-    componentRegistry: ComponentRegistry;
-    /** Parent context */
-    context?: BindingContext;
-}): RenderResult[];
-/**
- * Render a single node/element by ID from a layout
- * Useful for rendering specific parts of a component
- */
-declare function renderNode(options: {
-    /** Container element to render into */
-    container: HTMLElement;
-    /** All layout elements */
-    elements: LayoutElement[];
-    /** ID of the node to render */
-    nodeId: string;
-    /** Binding context */
-    context: BindingContext;
-    /** Whether to include children */
-    includeChildren?: boolean;
-    /** Event handlers */
-    eventHandlers?: Record<string, Record<string, (e: Event) => void>>;
-    /** Component registry */
-    componentRegistry?: ComponentRegistry;
-    /** Views map */
-    views?: Map<string, {
-        id: string;
-        layout: LayoutElement[];
-        props?: any;
-    }>;
-}): RenderResult | null;
-/**
- * Render into a shadow DOM for style isolation
- */
-declare function renderInShadow(options: RenderOptions & {
-    /** Shadow DOM mode */
-    mode?: 'open' | 'closed';
-    /** Styles to inject into shadow DOM */
-    styles?: string;
-    /** Whether to inject Tailwind CSS */
-    injectTailwind?: boolean;
-}): RenderResult & {
-    shadowRoot: ShadowRoot;
-};
-/**
- * Create a standalone Servly renderer with Tailwind CSS
- * This is the main entry point for standalone usage
- */
-declare function createServlyRenderer(options: {
-    /** Container element or selector */
-    container: HTMLElement | string;
-    /** Whether to inject Tailwind CSS */
-    injectTailwind?: boolean;
-    /** Custom Tailwind config */
-    tailwindConfig?: Record<string, any>;
-    /** Initial state */
-    initialState?: Record<string, any>;
-    /** State change callback */
-    onStateChange?: (event: {
-        key: string;
-        value: any;
-        previousValue: any;
-    }) => void;
-    /** Navigation callback */
-    onNavigate?: (url: string, options?: {
-        replace?: boolean;
-        state?: any;
-    }) => void;
-}): Promise<{
-    render: (elements: LayoutElement[], context?: BindingContext) => RenderResult;
-    renderNode: (elements: LayoutElement[], nodeId: string, context?: BindingContext) => RenderResult | null;
-    renderDynamicList: typeof renderDynamicList;
-    destroy: () => void;
-}>;
-/**
- * Create a views Map from an array of view objects
- * Helper function to convert application views to the format expected by render()
- *
- * @param views - Array of view objects with id and layout
- * @returns Map of view ID to view data
- */
-declare function createViewsMap(views: Array<{
-    id?: string;
-    _id?: string;
-    layout: LayoutElement[];
-    props?: any;
-}>): Map<string, {
-    id: string;
-    layout: LayoutElement[];
-    props?: any;
-}>;
-/**
- * Extract all component view IDs referenced in a layout
- * Useful for pre-fetching required views
- *
- * @param elements - Layout elements to scan
- * @returns Array of unique view IDs referenced
- */
-declare function extractReferencedViewIds(elements: LayoutElement[]): string[];
-/**
- * Recursively extract all view IDs from a set of views
- * Follows component view references to find all dependencies
- *
- * @param views - Map of all available views
- * @param startViewId - The view to start from
- * @returns Set of all view IDs needed to render the start view
- */
-declare function collectAllViewDependencies(views: Map<string, {
-    id: string;
-    layout: LayoutElement[];
-}>, startViewId: string): Set<string>;
-
-/**
- * Template Binding Resolution
- * Resolves {{path}} syntax in templates using binding context
- *
- * This module provides template resolution similar to RenderElements.tsx's
- * retrieveBody function, but in a framework-agnostic way.
- */
-
-/**
- * Check if a string contains template syntax
- */
-declare function hasTemplateSyntax(value: unknown): value is string;
-/**
- * Resolve a binding path to its value from context
- *
- * @param path - The path to resolve (e.g., "props.title", "state.count")
- * @param context - The binding context containing props, state, context
- * @returns The resolved value or undefined if not found
- */
-declare function resolveBindingPath(path: string, context: BindingContext): any;
-/**
- * Resolve a template string with bindings
- * Replaces all {{path}} occurrences with resolved values
- *
- * @param template - The template string containing {{path}} bindings
- * @param context - The binding context
- * @param componentId - Optional component ID for error tracking
- * @returns The resolved string
- */
-declare function resolveTemplate(template: string, context: BindingContext, componentId?: string): string;
-/**
- * Resolve a template and return the raw value (not stringified)
- * Useful for non-string values like objects, arrays, booleans
- *
- * @param template - The template string
- * @param context - The binding context
- * @param componentId - Optional component ID for error tracking
- */
-declare function resolveTemplateValue(template: string, context: BindingContext, componentId?: string): any;
-/**
- * Recursively resolve all template bindings in an object or array
- *
- * @param input - The input value (string, object, array, or primitive)
- * @param context - The binding context
- * @returns The input with all templates resolved
- */
-declare function resolveTemplatesDeep<T>(input: T, context: BindingContext): T;
-/**
- * Extract all binding keys from a template string
- *
- * @param template - The template string
- * @returns Array of binding keys found
- */
-declare function extractBindingKeys(template: string): string[];
-
-/**
- * Style Processing
- * Handles CSS styles, variables, and class names for DOM elements
- */
-
-/**
- * Convert camelCase to kebab-case
- */
-declare function camelToKebab(str: string): string;
-/**
- * Format a style value, adding px units if needed
- */
-declare function formatStyleValue(property: string, value: any): string;
-/**
- * Process a style object, resolving templates and formatting values
- */
-declare function processStyles(style: Record<string, any> | undefined, context: BindingContext): Record<string, string>;
-/**
- * Apply styles to a DOM element
- */
-declare function applyStyles(element: HTMLElement, styles: Record<string, string>): void;
-/**
- * Build combined styles from element configuration
- */
-declare function buildElementStyles(element: LayoutElement, context: BindingContext): Record<string, string>;
-/**
- * Build class name string from element configuration
- */
-declare function buildClassName(element: LayoutElement, context: BindingContext): string;
-/**
- * Clear all inline styles from an element
- */
-declare function clearStyles(element: HTMLElement): void;
-/**
- * Update styles on an element (diff and patch)
- */
-declare function updateStyles(element: HTMLElement, oldStyles: Record<string, string>, newStyles: Record<string, string>): void;
-
-/**
- * Component Cache System
- * In-memory and localStorage caching with LRU eviction
- */
-
-/** Default cache configuration */
-declare const DEFAULT_CACHE_CONFIG: Required<CacheConfig>;
-/**
- * Generate cache key for component
- */
-declare function getCacheKey(id: string, version?: string): string;
-/**
- * Clear memory cache
- */
-declare function clearMemoryCache(): void;
-/**
- * Get memory cache size
- */
-declare function getMemoryCacheSize(): number;
-/**
- * Clear localStorage cache
- */
-declare function clearLocalStorageCache(config?: CacheConfig): void;
-/**
- * Get component from cache (tries memory first, then localStorage)
- */
-declare function getFromCache(id: string, version?: string, strategy?: CacheStrategy, config?: CacheConfig): ComponentData | null;
-/**
- * Set component in cache
- */
-declare function setInCache(id: string, version: string, data: ComponentData, strategy?: CacheStrategy, config?: CacheConfig): void;
-/**
- * Clear all caches
- */
-declare function clearAllCaches(config?: CacheConfig): void;
-/**
- * Invalidate specific component from all caches
- */
-declare function invalidateCache(id: string, version?: string, config?: CacheConfig): void;
-
-/**
- * View Registry Fetcher
- * Fetches view data from the View Registry API with retry logic
- *
- * API Base: /api/views/registry
- * Supports: versioning, bundling, batch fetch, dependency resolution
- */
-
-/** Default retry configuration */
-declare const DEFAULT_RETRY_CONFIG: Required<RetryConfig>;
-/**
- * Configure the registry base URL
- */
-declare function setRegistryUrl(url: string): void;
-/**
- * Get the registry base URL
- */
-declare function getRegistryUrl(): string;
-/**
- * Fetch component with caching and retry
- */
-declare function fetchComponent(id: string, options?: FetchOptions): Promise<FetchResult>;
-/**
- * Fetch component with all dependencies resolved
- * Convenience wrapper that handles lazy loading
- */
-declare function fetchComponentWithDependencies(id: string, options?: FetchOptions): Promise<FetchResult>;
-/**
- * Batch fetch multiple views in a single request
- * Uses: POST /api/views/registry/batch
- */
-declare function batchFetchComponents(components: Array<{
-    id: string;
-    version?: string;
-}>, options?: Pick<FetchOptions, 'apiKey'>): Promise<Record<string, BundledComponent>>;
-/**
- * Prefetch views for faster loading
- * Uses: POST /api/views/registry/prefetch for version resolution
- */
-declare function prefetchComponents(ids: Array<{
-    id: string;
-    version?: string;
-}>, options?: Omit<FetchOptions, 'version'>): Promise<void>;
-/**
- * Check if view is available (in cache or online)
- * Uses: GET /api/views/registry/:viewId/available?version=^1.0.0
- */
-declare function isComponentAvailable(id: string, version?: string, options?: Pick<FetchOptions, 'apiKey' | 'cacheStrategy' | 'cacheConfig'>): Promise<{
-    available: boolean;
-    cached: boolean;
-    version?: string;
-}>;
-/**
- * Get dependency tree for a view
- * Uses: GET /api/views/registry/:viewId/dependencies?version=^1.0.0&depth=10
- */
-declare function getDependencyTree(id: string, options?: {
-    version?: string;
-    depth?: number;
-    apiKey?: string;
-}): Promise<{
-    tree: any;
-    totalDependencies: number;
-    maxDepthReached: number;
-}>;
-
-/**
- * Semantic Version Utilities
- * Parsing, comparison, and range resolution for semver
- */
-/** Parsed semantic version */
-interface ParsedVersion {
-    major: number;
-    minor: number;
-    patch: number;
-}
-/**
- * Parse a semantic version string
- * @returns Parsed version or null if invalid
- */
-declare function parseVersion(version: string): ParsedVersion | null;
-/**
- * Compare two versions
- * @returns -1 if a < b, 0 if a == b, 1 if a > b
- */
-declare function compareVersions(a: string, b: string): number;
-/**
- * Check if a version satisfies a specifier
- * Supports: exact (1.2.3), caret (^1.2.3), tilde (~1.2.3), latest, *
- */
-declare function satisfiesVersion(version: string, specifier: string): boolean;
-/**
- * Find the best matching version from a list
- * @param versions - Available versions (sorted newest first recommended)
- * @param specifier - Version specifier to match
- * @returns Best matching version or null if none match
- */
-declare function resolveVersion(versions: string[], specifier?: string): string | null;
-/**
- * Get next version based on bump type
- */
-declare function bumpVersion(currentVersion: string, bumpType: 'major' | 'minor' | 'patch'): string;
-/**
- * Check if a string is a valid version specifier
- */
-declare function isValidSpecifier(specifier: string): boolean;
-/**
- * Format a version for display
- */
-declare function formatVersion(version: string): string;
-
-/**
- * Test Runner for Servly Components
- *
- * Runs test cases against components to validate prop behavior
- * and DOM output matches expected assertions.
- */
-
-interface TestCase {
-    id: string;
-    name: string;
-    description?: string;
-    props: Record<string, any>;
-    assertions: Assertion[];
-}
-interface Assertion {
-    type: 'exists' | 'text' | 'attribute' | 'class' | 'style' | 'count' | 'visible';
-    selector: string;
-    expected?: any;
-    attribute?: string;
-    property?: string;
-}
-interface TestResult {
-    testId: string;
-    testName: string;
-    passed: boolean;
-    assertions: AssertionResult[];
-    duration: number;
-    error?: string;
-}
-interface AssertionResult {
-    assertion: Assertion;
-    passed: boolean;
-    actual?: any;
-    expected?: any;
-    message?: string;
-}
-interface TestSummary {
-    total: number;
-    passed: number;
-    failed: number;
-    duration: number;
-    results: TestResult[];
-}
-/**
- * Run a single test case against a component
- */
-declare function runTestCase(elements: LayoutElement[], testCase: TestCase, container?: HTMLElement): TestResult;
-/**
- * Run all test cases for a component
- */
-declare function runAllTests(elements: LayoutElement[], testCases: TestCase[]): TestSummary;
-/**
- * Validate a single assertion against the DOM
- */
-declare function validateAssertion(container: HTMLElement, assertion: Assertion): AssertionResult;
-/**
- * Validate props against prop definitions
- */
-declare function validateProps(props: Record<string, any>, definitions: PropDefinition[]): {
-    valid: boolean;
-    errors: string[];
-};
-/**
- * Generate test cases from prop definitions
- */
-declare function generateTestCases(definitions: PropDefinition[]): TestCase[];
-
-/**
- * Component Registry
- *
- * Manages a collection of components for dependency resolution.
- * Used by the renderer to resolve componentViewRef and blueprint references.
- */
-
-/**
- * Create a component registry from bundled data
- */
-declare function createRegistry(): ComponentRegistry;
-/**
- * Build a registry from component data with bundle
- */
-declare function buildRegistryFromBundle(data: ComponentData): ComponentRegistry;
-/**
- * Extract dependencies from layout elements
- * Scans for componentViewRef and blueprint references
- */
-declare function extractDependencies(elements: LayoutElement[]): Array<{
-    id: string;
-    version?: string;
-    type: 'viewRef' | 'blueprint';
-    elementId: string;
-}>;
-/**
- * Extract dependencies from event handler code
- * Looks for renderDynamicList calls
- */
-declare function extractDependenciesFromCode(code: string): Array<{
-    id: string;
-    type: 'blueprint';
-}>;
-/**
- * Recursively collect all dependencies from a component
- * Handles nested dependencies (A → B → C)
- */
-declare function collectAllDependencies(rootId: string, rootVersion: string, fetchComponent: (id: string, version?: string) => Promise<ComponentData | undefined>, maxDepth?: number): Promise<DependencyManifest>;
-/**
- * Check for circular dependencies
- */
-declare function detectCircularDependencies(manifest: DependencyManifest): string[] | null;
-
-/**
- * Component Analytics Types
- * Type definitions for analytics event collection and transmission
- */
-/**
- * Analytics configuration options
- */
-interface AnalyticsConfig {
-    /** Enable/disable analytics collection */
-    enabled: boolean;
-    /** Analytics API endpoint */
-    endpoint: string;
-    /** API key for authentication */
-    apiKey?: string;
-    /** Application ID to include in all events */
-    appId?: string;
-    /** Batch size before auto-flush */
-    batchSize: number;
-    /** Flush interval in milliseconds */
-    flushInterval: number;
-    /** Sample rate (0-1) for high-volume events */
-    sampleRate: number;
-    /** Environment identifier */
-    environment: 'development' | 'staging' | 'production';
-    /** Enable debug logging */
-    debug: boolean;
-}
-/**
- * Analytics event types
- */
-type AnalyticsEventType = 'render' | 'fetch' | 'error';
-/**
- * Base analytics event
- */
-interface AnalyticsEvent {
-    /** Event type */
-    type: AnalyticsEventType;
-    /** Component identifier */
-    componentId: string;
-    /** Component version */
-    version: string;
-    /** Unix timestamp in milliseconds */
-    timestamp: number;
-    /** Anonymous session ID */
-    sessionId?: string;
-    /** Application ID */
-    appId?: string;
-    /** Duration in milliseconds */
-    duration?: number;
-    /** Event-specific metadata */
-    metadata?: Record<string, unknown>;
-}
-/**
- * Metadata for render events
- */
-interface RenderMetadata {
-    /** Number of DOM elements rendered */
-    elementCount?: number;
-    /** Whether component was served from cache */
-    fromCache?: boolean;
-    /** Memory heap change in KB (Chrome only) */
-    heapDeltaKB?: number;
-    /** Number of DOM nodes created */
-    domNodesCreated?: number;
-    /** Number of long tasks (>50ms) during render */
-    longTaskCount?: number;
-    /** Whether component has event handlers */
-    hasEventHandlers?: boolean;
-    /** Whether component has dependencies */
-    hasDependencies?: boolean;
-}
-/**
- * Metadata for fetch events
- */
-interface FetchMetadata {
-    /** Whether fetch was a cache hit */
-    cacheHit: boolean;
-    /** Fetch duration in milliseconds */
-    fetchDuration: number;
-    /** Bundle size in bytes */
-    bundleSize?: number;
-    /** Number of dependencies */
-    dependencyCount?: number;
-}
-/**
- * Error types for error events
- */
-type ErrorType = 'render' | 'fetch' | 'binding';
-/**
- * Metadata for error events
- */
-interface ErrorMetadata {
-    /** Type of error */
-    errorType: ErrorType;
-    /** Error message (max 1000 chars) */
-    errorMessage: string;
-    /** Stack trace (truncated to 500 chars) */
-    stackTrace?: string;
-    /** Failed binding path (for binding errors) */
-    bindingPath?: string;
-    /** Element ID where error occurred */
-    elementId?: string;
-}
-/**
- * Client info included in batch requests
- */
-interface ClientInfo {
-    /** SDK version */
-    sdkVersion: string;
-    /** Environment */
-    environment: string;
-}
-/**
- * Batch events request body
- */
-interface BatchEventsRequest {
-    /** Array of analytics events */
-    events: AnalyticsEvent[];
-    /** Client information */
-    clientInfo: ClientInfo;
-}
-/**
- * Batch events response
- */
-interface BatchEventsResponse {
-    /** Whether request was successful */
-    success: boolean;
-    /** Number of events accepted */
-    accepted: number;
-    /** Number of events rejected */
-    rejected: number;
-    /** Error messages for rejected events */
-    errors?: string[];
-    /** Retry-After header value (for rate limiting) */
-    retryAfter?: number;
-}
-/**
- * Session information
- */
-interface SessionInfo {
-    /** Session ID */
-    id: string;
-    /** Timestamp when session was created */
-    createdAt: number;
-    /** Timestamp of last activity */
-    lastActivityAt: number;
-}
-
-/**
- * Component Analytics
- * Collects and transmits component usage, performance, and error metrics
- */
-
-/**
- * Analytics Collector class
- * Manages event collection, batching, and transmission
- */
-declare class AnalyticsCollector {
-    private config;
-    private eventQueue;
-    private flushTimer;
-    private isEnabled;
-    private isFlushing;
-    private retryDelay;
-    constructor(config?: Partial<AnalyticsConfig>);
-    /**
-     * Configure analytics
-     */
-    configure(config: Partial<AnalyticsConfig>): void;
-    /**
-     * Disable analytics collection
-     */
-    disable(): void;
-    /**
-     * Enable analytics collection
-     */
-    enable(): void;
-    /**
-     * Destroy and cleanup
-     */
-    destroy(): void;
-    /**
-     * Track component render
-     */
-    trackRender(componentId: string, version: string, duration: number, metadata?: RenderMetadata): void;
-    /**
-     * Track component fetch
-     */
-    trackFetch(componentId: string, version: string, duration: number, fromCache: boolean, metadata?: Partial<FetchMetadata>): void;
-    /**
-     * Track error
-     */
-    trackError(componentId: string, version: string, error: Error, context?: Partial<ErrorMetadata>): void;
-    /**
-     * Check if event should be tracked (sampling + enabled)
-     */
-    private shouldTrack;
-    /**
-     * Add event to queue
-     */
-    private queueEvent;
-    /**
-     * Get current queue size
-     */
-    getQueueSize(): number;
-    /**
-     * Start the flush timer
-     */
-    private startFlushTimer;
-    /**
-     * Stop the flush timer
-     */
-    private stopFlushTimer;
-    /**
-     * Flush events to server
-     */
-    flush(): Promise<void>;
-    /**
-     * Perform the actual flush
-     */
-    private doFlush;
-    /**
-     * Send events to the API
-     */
-    private sendEvents;
-    /**
-     * Handle failed events (partial success)
-     */
-    private handleFailedEvents;
-    /**
-     * Handle network error
-     */
-    private handleNetworkError;
-    /**
-     * Schedule a retry flush
-     */
-    private scheduleRetry;
-    /**
-     * Truncate string to max length
-     */
-    private truncateString;
-    /**
-     * Log debug message
-     */
-    private log;
-}
-/**
- * Get the analytics collector singleton
- */
-declare function getAnalytics(): AnalyticsCollector;
-/**
- * Configure analytics (convenience function)
- */
-declare function configureAnalytics(config: Partial<AnalyticsConfig>): void;
-/**
- * Reset analytics (for testing)
- */
-declare function resetAnalytics(): void;
-declare const analytics: {
-    readonly instance: AnalyticsCollector;
-    configure: typeof configureAnalytics;
-    trackRender: (componentId: string, version: string, duration: number, metadata?: RenderMetadata) => void;
-    trackFetch: (componentId: string, version: string, duration: number, fromCache: boolean, metadata?: Partial<FetchMetadata>) => void;
-    trackError: (componentId: string, version: string, error: Error, context?: Partial<ErrorMetadata>) => void;
-    flush: () => Promise<void>;
-    disable: () => void;
-    enable: () => void;
-};
-
-/**
- * Session Manager
- * Manages anonymous session IDs for analytics tracking
- */
-
-/**
- * Session Manager class
- * Manages anonymous session IDs with automatic rotation
- */
-declare class SessionManager {
-    private session;
-    constructor();
-    /**
-     * Initialize session manager
-     */
-    private initialize;
-    /**
-     * Create a new session
-     */
-    private createNewSession;
-    /**
-     * Get current session ID
-     * Creates new session if expired
-     */
-    getSessionId(): string;
-    /**
-     * Update last activity timestamp
-     */
-    touch(): void;
-    /**
-     * Force create a new session
-     */
-    rotate(): void;
-    /**
-     * Clear current session
-     */
-    clear(): void;
-    /**
-     * Get session info (for debugging)
-     */
-    getSessionInfo(): SessionInfo | null;
-}
-/**
- * Get the session manager singleton
- */
-declare function getSessionManager(): SessionManager;
-/**
- * Reset the session manager (for testing)
- */
-declare function resetSessionManager(): void;
-
-/**
- * Memory Sampler
- * Samples memory usage using Chrome's performance.memory API
- * Gracefully degrades on unsupported browsers
- */
-/**
- * Memory sample data
- */
-interface MemorySample {
-    /** Used JS heap size in KB */
-    heapUsedKB: number;
-    /** Total JS heap size in KB */
-    heapTotalKB: number;
-    /** Timestamp when sample was taken */
-    timestamp: number;
-}
-/**
- * Memory Sampler class
- * Provides memory sampling functionality for Chrome browsers
- */
-declare class MemorySampler {
-    private isSupported;
-    constructor();
-    /**
-     * Check if memory API is available
-     */
-    private checkSupport;
-    /**
-     * Check if memory sampling is available
-     */
-    isAvailable(): boolean;
-    /**
-     * Take a memory sample
-     * Returns null if memory API is not available
-     */
-    sample(): MemorySample | null;
-    /**
-     * Calculate heap delta between two samples
-     * Returns the difference in KB (positive = memory increased)
-     */
-    calculateDelta(before: MemorySample | null, after: MemorySample | null): number | null;
-}
-/**
- * Get the memory sampler singleton
- */
-declare function getMemorySampler(): MemorySampler;
-/**
- * Reset the memory sampler (for testing)
- */
-declare function resetMemorySampler(): void;
-
-/**
- * Long Task Observer
- * Observes long tasks (>50ms) using PerformanceObserver API
- * Gracefully degrades on unsupported browsers
- */
-/**
- * Long Task Observer class
- * Counts tasks that take longer than 50ms during a measurement period
- */
-declare class LongTaskObserver {
-    private observer;
-    private longTaskCount;
-    private isSupported;
-    private isObserving;
-    constructor();
-    /**
-     * Check if PerformanceObserver with longtask support is available
-     */
-    private checkSupport;
-    /**
-     * Check if long task observation is available
-     */
-    isAvailable(): boolean;
-    /**
-     * Start observing long tasks
-     */
-    start(): void;
-    /**
-     * Stop observing and return the count of long tasks
-     */
-    stop(): number;
-    /**
-     * Reset the long task counter
-     */
-    reset(): void;
-    /**
-     * Get current count without stopping observation
-     */
-    getCount(): number;
-    /**
-     * Check if currently observing
-     */
-    isActive(): boolean;
-}
-/**
- * Get the long task observer singleton
- */
-declare function getLongTaskObserver(): LongTaskObserver;
-/**
- * Reset the long task observer (for testing)
- */
-declare function resetLongTaskObserver(): void;
-
-/**
- * State Manager for Runtime Core
- * Provides state management capabilities similar to RenderElements.tsx
- * but in a framework-agnostic way.
- */
-interface StateChangeEvent {
-    key: string;
-    value: any;
-    previousValue: any;
-    operation: 'set' | 'merge' | 'delete' | 'append' | 'prepend' | 'toggle';
-    elementId?: string;
-    timestamp: number;
-}
-interface StateManagerConfig {
-    /** Initial state */
-    initialState?: Record<string, any>;
-    /** Callback when state changes */
-    onStateChange?: (event: StateChangeEvent) => void;
-    /** Whether to persist state to localStorage */
-    persistToLocalStorage?: boolean;
-    /** localStorage key prefix */
-    localStoragePrefix?: string;
-    /** Whether to sync with sessionStorage */
-    syncWithSessionStorage?: boolean;
-}
-/**
- * Framework-agnostic state manager
- * Provides setState, getState, and state change notifications
- */
-declare class StateManager {
-    private state;
-    private listeners;
-    private config;
-    constructor(config?: StateManagerConfig);
-    /**
-     * Get value by path from state
-     */
-    get(path: string): any;
-    /**
-     * Get the entire state object
-     */
-    getState(): Record<string, any>;
-    /**
-     * Set a value in state
-     */
-    set(key: string, value: any, elementId?: string): void;
-    /**
-     * Merge an object into state at the given path
-     */
-    merge(key: string, value: Record<string, any>, deep?: boolean, elementId?: string): void;
-    /**
-     * Delete a key from state
-     */
-    delete(key: string, elementId?: string): void;
-    /**
-     * Append to an array in state
-     */
-    append(key: string, value: any, elementId?: string): void;
-    /**
-     * Prepend to an array in state
-     */
-    prepend(key: string, value: any, elementId?: string): void;
-    /**
-     * Toggle a boolean value in state
-     */
-    toggle(key: string, elementId?: string): void;
-    /**
-     * Subscribe to state changes
-     */
-    subscribe(listener: (event: StateChangeEvent) => void): () => void;
-    /**
-     * Notify all listeners of a state change
-     */
-    private notifyChange;
-    /**
-     * Load state from localStorage
-     */
-    private loadFromLocalStorage;
-    /**
-     * Save state to localStorage
-     */
-    private saveToLocalStorage;
-    /**
-     * Clear all state
-     */
-    clear(): void;
-}
-/**
- * Get value by dot-notation path
- */
-declare function getValueByPath(obj: any, path: string): any;
-/**
- * Set value by dot-notation path
- */
-declare function setValueByPath(obj: any, path: string, value: any): void;
-/**
- * Delete value by dot-notation path
- */
-declare function deleteValueByPath(obj: any, path: string): void;
-/**
- * Deep merge two objects
- */
-declare function deepMerge(target: any, source: any): any;
-/**
- * Add a class to an element's className string
- */
-declare function addClass(currentClasses: string, classToAdd: string): string;
-/**
- * Remove a class from an element's className string
- */
-declare function removeClass(currentClasses: string, classToRemove: string): string;
-/**
- * Toggle a class in an element's className string
- */
-declare function toggleClass(currentClasses: string, classToToggle: string): string;
-/**
- * Check if a className string contains a specific class
- */
-declare function hasClass(currentClasses: string, classToCheck: string): boolean;
-/**
- * Get value from localStorage with JSON parsing
- */
-declare function getLocalStorage(key: string, defaultValue?: any): any;
-/**
- * Set value in localStorage with JSON stringification
- */
-declare function setLocalStorage(key: string, value: any): void;
-/**
- * Remove value from localStorage
- */
-declare function removeLocalStorage(key: string): void;
-/**
- * Get value from sessionStorage with JSON parsing
- */
-declare function getSessionStorage(key: string, defaultValue?: any): any;
-/**
- * Set value in sessionStorage with JSON stringification
- */
-declare function setSessionStorage(key: string, value: any): void;
-/**
- * Remove value from sessionStorage
- */
-declare function removeSessionStorage(key: string): void;
-interface NavigationOptions {
-    /** Replace current history entry instead of pushing */
-    replace?: boolean;
-    /** State to pass to the new route */
-    state?: any;
-    /** Open in new tab */
-    newTab?: boolean;
-}
-/**
- * Navigate to a URL
- * Works with both hash-based and history-based routing
- */
-declare function navigateTo(url: string, options?: NavigationOptions): void;
-/**
- * Go back in history
- */
-declare function goBack(): void;
-/**
- * Go forward in history
- */
-declare function goForward(): void;
-/**
- * Get current URL information
- */
-declare function getUrlInfo(): {
-    href: string;
-    pathname: string;
-    search: string;
-    hash: string;
-    searchParams: Record<string, string>;
-};
-
-/**
- * Event System for Runtime Core
- * Provides event handling capabilities similar to RenderElements.tsx
- * but in a framework-agnostic way.
- *
- * This module provides:
- * - Event handler creation and management
- * - Event delegation and bubbling control
- * - Integration with state management
- * - Support for Servly plugin format (via callbacks)
- */
-
-interface EventHandlerConfig {
-    /** Prevent default browser behavior */
-    preventDefault?: boolean;
-    /** Stop event propagation */
-    stopPropagation?: boolean;
-    /** Debounce delay in ms */
-    debounce?: number;
-    /** Throttle delay in ms */
-    throttle?: number;
-    /** Only trigger once */
-    once?: boolean;
-}
-interface ServlyPluginAction {
-    /** Plugin key (e.g., 'state-setState', 'navigateTo') */
-    key: string;
-    /** Plugin configuration */
-    config?: Record<string, any>;
-    /** Plugin name for debugging */
-    name?: string;
-}
-interface ServlyEventHandler {
-    /** Array of plugin actions to execute */
-    plugins?: ServlyPluginAction[];
-    /** Event handler configuration */
-    preventDefault?: boolean;
-    stopPropagation?: boolean;
-}
-interface EventContext {
-    /** The DOM event */
-    event: Event;
-    /** Element ID that triggered the event */
-    elementId: string;
-    /** Current binding context */
-    context: BindingContext;
-    /** State manager instance */
-    stateManager?: StateManager;
-    /** Current item data (for list items) */
-    currentItem?: any;
-    /** Current index (for list items) */
-    currentIndex?: number;
-}
-type PluginExecutor = (action: ServlyPluginAction, eventContext: EventContext) => Promise<any> | any;
-interface EventSystemConfig {
-    /** State manager instance */
-    stateManager?: StateManager;
-    /** Custom plugin executors */
-    pluginExecutors?: Record<string, PluginExecutor>;
-    /** Callback when an event is triggered */
-    onEvent?: (eventName: string, elementId: string, event: Event) => void;
-    /** Callback when a plugin action is executed */
-    onPluginExecute?: (action: ServlyPluginAction, result: any) => void;
-    /** Callback for navigation requests */
-    onNavigate?: (url: string, options?: {
-        replace?: boolean;
-        state?: any;
-    }) => void;
-    /** Callback for external API calls */
-    onApiCall?: (config: any) => Promise<any>;
-}
-/**
- * Event system for managing event handlers in runtime-core
- */
-declare class EventSystem {
-    private config;
-    private pluginExecutors;
-    private debounceTimers;
-    private throttleTimers;
-    constructor(config?: EventSystemConfig);
-    /**
-     * Register a custom plugin executor
-     */
-    registerPlugin(key: string, executor: PluginExecutor): void;
-    /**
-     * Create an event handler from Servly plugin format
-     */
-    createHandler(elementId: string, handlerConfig: ServlyEventHandler, context: BindingContext, options?: EventHandlerConfig): (event: Event) => void;
-    /**
-     * Execute a sequence of plugin actions
-     */
-    executePlugins(plugins: ServlyPluginAction[], eventContext: EventContext): Promise<any[]>;
-    /**
-     * Create a debounced event handler
-     */
-    createDebouncedHandler(elementId: string, handler: (event: Event) => void, delay: number): (event: Event) => void;
-    /**
-     * Create a throttled event handler
-     */
-    createThrottledHandler(elementId: string, handler: (event: Event) => void, delay: number): (event: Event) => void;
-    /**
-     * Clean up all timers
-     */
-    destroy(): void;
-}
-/**
- * Standard DOM event names that map to React-style event props
- */
-declare const EVENT_HANDLERS: Record<string, string>;
-/**
- * Convert React-style event name to DOM event name
- */
-declare function toDomEventName(reactEventName: string): string;
-/**
- * Convert DOM event name to React-style event name
- */
-declare function toReactEventName(domEventName: string): string;
-declare function getEventSystem(config?: EventSystemConfig): EventSystem;
-declare function resetEventSystem(): void;
-
-/**
- * Tailwind CSS Utilities for Runtime Core
- * Provides automatic Tailwind CSS injection for standalone rendering
- */
-interface TailwindConfig {
-    /** Custom CDN URL for Tailwind */
-    cdnUrl?: string;
-    /** Tailwind configuration object */
-    config?: Record<string, any>;
-    /** Custom plugins to load */
-    plugins?: string[];
-    /** Whether to use the Play CDN (includes all plugins) */
-    usePlayCdn?: boolean;
-    /** Callback when Tailwind is ready */
-    onReady?: () => void;
-    /** Callback on error */
-    onError?: (error: Error) => void;
-}
-/**
- * Inject Tailwind CSS into the document
- * Uses the Tailwind CDN for quick setup
- */
-declare function injectTailwind(config?: TailwindConfig): Promise<void>;
-/**
- * Remove Tailwind CSS from the document
- */
-declare function removeTailwind(): void;
-/**
- * Check if Tailwind CSS is loaded
- */
-declare function isTailwindLoaded(): boolean;
-/**
- * Get the Tailwind instance (if loaded)
- */
-declare function getTailwind(): any;
-/**
- * Update Tailwind configuration at runtime
- */
-declare function updateTailwindConfig(config: Record<string, any>): void;
-/**
- * Add custom CSS to the document
- * Useful for adding custom styles alongside Tailwind
- */
-declare function addCustomStyles(css: string, id?: string): HTMLStyleElement;
-/**
- * Remove custom styles by ID
- */
-declare function removeCustomStyles(id: string): void;
-/**
- * Default Tailwind configuration for Servly components
- */
-declare const DEFAULT_SERVLY_TAILWIND_CONFIG: {
-    theme: {
-        extend: {};
-    };
-    safelist: {
-        pattern: RegExp;
-    }[];
-};
-/**
- * Initialize Tailwind with Servly defaults
- */
-declare function initServlyTailwind(customConfig?: Record<string, any>): Promise<void>;
-
-/**
- * Overrides System for Runtime Core
- * Handles element overrides with dependency tracking
- *
- * Overrides are stored in element.configuration._overrides_ and contain:
- * - plugins: Array of plugin actions to execute
- * - dependencies: Array of template strings to watch for changes
- * - isCleanUp: Boolean flag for unmount actions
- */
-
-interface Override {
-    /** Plugin actions to execute */
-    plugins?: ServlyPluginAction[];
-    /** Template strings to watch for changes */
-    dependencies?: string[];
-    /** Whether this is a cleanup override (runs on unmount) */
-    isCleanUp?: boolean;
-    /** Override name for debugging */
-    name?: string;
-}
-interface OverrideState {
-    /** Previous resolved dependency values */
-    previousValues: Map<number, any[]>;
-    /** Whether the override has been initialized */
-    initialized: boolean;
-    /** Abort controller for cancelling pending operations */
-    abortController?: AbortController;
-}
-interface OverrideSystemConfig {
-    /** Event system for executing plugins */
-    eventSystem?: EventSystem;
-    /** State manager for state operations */
-    stateManager?: StateManager;
-    /** Callback when an override is triggered */
-    onOverrideTrigger?: (elementId: string, override: Override, eventType: string) => void;
-    /** Callback when dependencies change */
-    onDependencyChange?: (elementId: string, dependencies: string[], values: any[]) => void;
-}
-/**
- * Manages element overrides with dependency tracking
- */
-declare class OverrideSystem {
-    private config;
-    private elementStates;
-    private watchIntervals;
-    constructor(config?: OverrideSystemConfig);
-    /**
-     * Get overrides from an element
-     */
-    getOverrides(element: LayoutElement): Override[];
-    /**
-     * Initialize overrides for an element (called on mount)
-     */
-    initializeElement(element: LayoutElement, context: BindingContext): Promise<void>;
-    /**
-     * Check and process dependency changes for an element
-     */
-    checkDependencies(element: LayoutElement, context: BindingContext): Promise<void>;
-    /**
-     * Cleanup overrides for an element (called on unmount)
-     */
-    cleanupElement(element: LayoutElement, context: BindingContext): Promise<void>;
-    /**
-     * Process a list of overrides
-     */
-    private processOverrides;
-    /**
-     * Start watching an element for dependency changes
-     */
-    startWatching(element: LayoutElement, context: BindingContext, intervalMs?: number): void;
-    /**
-     * Stop watching an element
-     */
-    stopWatching(elementId: string): void;
-    /**
-     * Destroy the override system
-     */
-    destroy(): void;
-}
-/**
- * Extract all dependencies from overrides
- */
-declare function extractOverrideDependencies(element: LayoutElement): string[];
-/**
- * Check if an element has overrides
- */
-declare function hasOverrides(element: LayoutElement): boolean;
-/**
- * Check if an element has dependency-based overrides
- */
-declare function hasDependencyOverrides(element: LayoutElement): boolean;
-/**
- * Get mount overrides for an element
- */
-declare function getMountOverrides(element: LayoutElement): Override[];
-/**
- * Get cleanup overrides for an element
- */
-declare function getCleanupOverrides(element: LayoutElement): Override[];
-declare function getOverrideSystem(config?: OverrideSystemConfig): OverrideSystem;
-declare function resetOverrideSystem(): void;
-
-export { AnalyticsCollector, type AnalyticsConfig, type AnalyticsEvent, type AnalyticsEventType, type Assertion$1 as Assertion, type AssertionResult$1 as AssertionResult, type BatchEventsRequest, type BatchEventsResponse, type BindingContext, type BundleStrategy, type BundledComponent, type CacheConfig, type CacheEntry, type CacheStrategy, type ClientInfo, type ComponentBundle, type ComponentData, type ComponentRegistry, DEFAULT_CACHE_CONFIG, DEFAULT_RETRY_CONFIG, DEFAULT_SERVLY_TAILWIND_CONFIG, type DependencyEntry, type DependencyManifest, type DependencyType, EVENT_HANDLERS, type ElementConfig, type ErrorMetadata, type ErrorType, type EventContext, type EventHandlerConfig, EventSystem, type EventSystemConfig, type FetchMetadata, type FetchOptions, type FetchResult, type LayoutElement, LongTaskObserver, MemorySampler, type NavigationOptions, type Override, type OverrideState, OverrideSystem, type OverrideSystemConfig, type ParsedVersion, type PluginExecutor, type PropDefinition, type RenderMetadata, type RenderOptions, type RenderResult, type RetryConfig, type ServlyEventHandler, type ServlyPluginAction, type SessionInfo, SessionManager, type StateChangeEvent, StateManager, type StateManagerConfig, type TailwindConfig, type AssertionResult as TestAssertionResult, type TestCase$1 as TestCase, type TestCase as TestCaseInput, type TestCaseResult, type TestResult, type TestSummary as TestRunSummary, type TestSummary$1 as TestSummary, type ViewData, addClass, addCustomStyles, analytics, applyStyles, batchFetchComponents, buildClassName, buildElementStyles, buildRegistryFromBundle, bumpVersion, camelToKebab, clearAllCaches, clearLocalStorageCache, clearMemoryCache, clearStyles, collectAllDependencies, collectAllViewDependencies, compareVersions, configureAnalytics, createRegistry, createServlyRenderer, createViewsMap, deepMerge, deleteValueByPath, detectCircularDependencies, extractBindingKeys, extractDependencies, extractDependenciesFromCode, extractOverrideDependencies, extractReferencedViewIds, fetchComponent, fetchComponentWithDependencies, formatStyleValue, formatVersion, generateTestCases, getAnalytics, getCacheKey, getCleanupOverrides, getDependencyTree, getEventSystem, getFromCache, getLocalStorage, getLongTaskObserver, getMemoryCacheSize, getMemorySampler, getMountOverrides, getOverrideSystem, getRegistryUrl, getSessionManager, getSessionStorage, getTailwind, getUrlInfo, getValueByPath, goBack, goForward, hasClass, hasDependencyOverrides, hasOverrides, hasTemplateSyntax, initServlyTailwind, injectTailwind, invalidateCache, isComponentAvailable, isTailwindLoaded, isValidSpecifier, navigateTo, parseVersion, prefetchComponents, processStyles, removeClass, removeCustomStyles, removeLocalStorage, removeSessionStorage, removeTailwind, render, renderDynamicList, renderInShadow, renderNode, resetAnalytics, resetEventSystem, resetLongTaskObserver, resetMemorySampler, resetOverrideSystem, resetSessionManager, resolveBindingPath, resolveTemplate, resolveTemplateValue, resolveTemplatesDeep, resolveVersion, runAllTests, runTestCase, satisfiesVersion, setInCache, setLocalStorage, setRegistryUrl, setSessionStorage, setValueByPath, toDomEventName, toReactEventName, toggleClass, updateStyles, updateTailwindConfig, validateAssertion, validateProps };