@servlyadmin/runtime-core 0.1.7 → 0.1.8

package/dist/index.d.ts

@@ -71,6 +71,10 @@ interface ElementConfig {
     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 */
@@ -98,6 +102,8 @@ interface LayoutElement {
     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
@@ -139,6 +145,31 @@ interface RenderOptions {
     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
@@ -235,6 +266,21 @@ interface BundledComponent {
 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
  */
@@ -265,6 +311,8 @@ interface ComponentData {
     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
@@ -337,6 +385,8 @@ interface FetchOptions {
     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
@@ -355,6 +405,12 @@ interface FetchResult {
         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
@@ -403,7 +459,10 @@ interface TestSummary$1 {
 /**
  * Vanilla DOM Renderer
  * Renders Layout JSON to native DOM elements
- * Supports component dependencies via componentViewRef and blueprint
+ * 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.
  */
 
 /**
@@ -434,10 +493,119 @@ declare function renderDynamicList(options: {
     /** 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.
  */
 
 /**
@@ -1210,4 +1378,465 @@ declare function getLongTaskObserver(): LongTaskObserver;
  */
 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 };
+/**
+ * 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 };