import { a as FNodeChild, F as FNode } from './types-eDz8Zr3v.js';
import { b as SerializedState } from './types-C5UPsdAS.js';

/**
 * f() - Create FNodes without JSX
 */
declare function f(type: string | ((...args: any[]) => unknown), props?: Record<string, unknown>, ...children: FNodeChild[]): FNode;

declare function resetRender(): void;
declare function render(app: FNodeChild | (() => FNodeChild), container: HTMLElement): () => void;

interface HydrateOptions {
    /**
     * Serialized state from server
     * Typically embedded in HTML as JSON script tag
     */
    state?: SerializedState;
    /**
     * Called when hydration completes successfully
     */
    onHydrated?: () => void;
    /**
     * Called when hydration fails (falls back to full render)
     */
    onMismatch?: (error: Error) => void;
}
/**
 * Hydrate server-rendered HTML with client-side interactivity
 */
declare function hydrate(app: FNodeChild | (() => FNodeChild), container: HTMLElement, options?: HydrateOptions): void;

interface SuspenseProps {
    /** Fallback UI to display while loading */
    fallback: FNodeChild;
    /** Children to render when loaded */
    children: FNodeChild;
}
interface LazyComponent<P = Record<string, unknown>> {
    (props: P): FNodeChild;
    _lazy: true;
    _loader: () => Promise<{
        default: (props: P) => FNodeChild;
    }>;
    _resolved?: (props: P) => FNodeChild;
    _promise?: Promise<unknown>;
    _error?: Error;
}
interface ErrorInfo {
    /** Component stack trace */
    componentStack: string;
    /** Error occurred during which phase */
    phase: 'render' | 'effect' | 'event';
}
interface ErrorBoundaryProps {
    /** Fallback UI to display when error occurs */
    fallback: FNodeChild | ((error: Error, info: ErrorInfo) => FNodeChild);
    /** Callback when error is caught */
    onError?: (error: Error, info: ErrorInfo) => void;
    /** Children to render */
    children: FNodeChild;
    /** Key to reset boundary (changing key resets error state) */
    resetKey?: unknown;
}

/**
 * Suspense component that shows fallback while children are loading
 *
 * @example
 * ```tsx
 * const Dashboard = lazy(() => import('./Dashboard'))
 *
 * function App() {
 *   return (
 *     <Suspense fallback={<div>Loading...</div>}>
 *       <Dashboard />
 *     </Suspense>
 *   )
 * }
 * ```
 */
declare function Suspense(props: SuspenseProps): FNodeChild;

/**
 * ErrorBoundary component that catches errors in its children and displays fallback UI
 *
 * @example
 * ```tsx
 * <ErrorBoundary
 *   fallback={(error, info) => <div>Error: {error.message}</div>}
 *   onError={(error, info) => console.error(error)}
 * >
 *   <App />
 * </ErrorBoundary>
 * ```
 */
declare function ErrorBoundary(props: ErrorBoundaryProps): FNodeChild;

/**
 * Creates a lazy-loaded component for code splitting
 *
 * @example
 * ```tsx
 * const Dashboard = lazy(() => import('./Dashboard'))
 * const Settings = lazy(() => import('./Settings'))
 *
 * function App() {
 *   return (
 *     <Suspense fallback={<div>Loading...</div>}>
 *       <Dashboard />
 *     </Suspense>
 *   )
 * }
 * ```
 */
declare function lazy<P = Record<string, unknown>>(loader: () => Promise<{
    default: (props: P) => FNodeChild;
}>): LazyComponent<P>;

export { ErrorBoundary, type ErrorBoundaryProps, type ErrorInfo, type HydrateOptions, type LazyComponent, Suspense, type SuspenseProps, f, hydrate, lazy, render, resetRender };