@servlyadmin/runtime-core 0.1.7 → 0.1.9

package/dist/index.d.cts

@@ -1,1213 +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;
-    /** 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;
-}
-/**
- * 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;
-}
-/**
- * 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;
-}
-/**
- * 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;
-}
-/**
- * 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;
-}
-/**
- * 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;
-    }>;
-}
-/**
- * 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 and blueprint
- */
-
-/**
- * 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[];
-
-/**
- * Template Binding Resolution
- * Resolves {{path}} syntax in templates using binding context
- */
-
-/**
- * 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;
-
-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, type DependencyEntry, type DependencyManifest, type DependencyType, type ElementConfig, type ErrorMetadata, type ErrorType, type FetchMetadata, type FetchOptions, type FetchResult, type LayoutElement, LongTaskObserver, MemorySampler, type ParsedVersion, type PropDefinition, type RenderMetadata, type RenderOptions, type RenderResult, type RetryConfig, type SessionInfo, SessionManager, 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, analytics, applyStyles, batchFetchComponents, buildClassName, buildElementStyles, buildRegistryFromBundle, bumpVersion, camelToKebab, clearAllCaches, clearLocalStorageCache, clearMemoryCache, clearStyles, collectAllDependencies, compareVersions, configureAnalytics, createRegistry, detectCircularDependencies, extractBindingKeys, extractDependencies, extractDependenciesFromCode, fetchComponent, fetchComponentWithDependencies, formatStyleValue, formatVersion, generateTestCases, getAnalytics, getCacheKey, getDependencyTree, getFromCache, getLongTaskObserver, getMemoryCacheSize, getMemorySampler, getRegistryUrl, getSessionManager, hasTemplateSyntax, invalidateCache, isComponentAvailable, isValidSpecifier, parseVersion, prefetchComponents, processStyles, render, renderDynamicList, resetAnalytics, resetLongTaskObserver, resetMemorySampler, resetSessionManager, resolveBindingPath, resolveTemplate, resolveTemplateValue, resolveTemplatesDeep, resolveVersion, runAllTests, runTestCase, satisfiesVersion, setInCache, setRegistryUrl, updateStyles, validateAssertion, validateProps };