import type { Children, Component, Context } from "./crank.js";
/**
 * Creates a lazy-loaded component from an initializer function.
 *
 * @param initializer - Function that returns a Promise resolving to a component or module
 * @returns A component that loads the target component on first render
 *
 * @example
 * ```jsx
 * const LazyComponent = lazy(() => import('./MyComponent'));
 *
 * <Suspense fallback={<div>Loading...</div>}>
 *   <LazyComponent prop="value" />
 * </Suspense>
 * ```
 */
export declare function lazy<T extends Component>(initializer: () => Promise<T | {
    default: T;
}>): T;
/**
 * A component that displays a fallback while its children are loading.
 *
 * When used within a SuspenseList, coordinates with siblings to control
 * reveal order and fallback behavior.
 *
 * @param children - The content to display when loading is complete
 * @param fallback - The content to display while children are loading
 * @param timeout - Time in milliseconds before showing fallback (defaults to
 * 300ms standalone, or inherits from SuspenseList)
 *
 * @example
 * ```jsx
 * <Suspense fallback={<div>Loading...</div>}>
 *   <AsyncComponent />
 * </Suspense>
 * ```
 */
export declare function Suspense(this: Context, { children, fallback, timeout, }: {
    children: Children;
    fallback: Children;
    timeout?: number;
}): AsyncGenerator<Children>;
declare const SuspenseListController: unique symbol;
interface SuspenseListItem {
    ctx: Context;
    resolve: () => void;
    promise: Promise<void>;
}
interface SuspenseListController {
    timeout?: number;
    revealOrder?: "forwards" | "backwards" | "together";
    tail?: "collapsed" | "hidden";
    register(ctx: Context): Promise<Array<SuspenseListItem>>;
    isHead(ctx: Context, items: Array<SuspenseListItem>): boolean;
    scheduleFallback(ctx: Context, items: Array<SuspenseListItem>): Promise<void>;
    scheduleChildren(ctx: Context, items: Array<SuspenseListItem>): Promise<void>;
}
declare global {
    namespace Crank {
        interface ProvisionMap {
            [SuspenseListController]: SuspenseListController;
        }
    }
}
/**
 * Controls when child <Suspense> components show their content or fallbacks
 * based on the specified reveal order. The <SuspenseList> resolves when
 * coordination effort is complete (not necessarily when all content is
 * loaded).
 *
 * @param revealOrder - How children should be revealed:
 *   - "forwards" (default): Show children in document order, waiting for
 *     predecessors
 *   - "backwards": Show children in reverse order, waiting for successors
 *   - "together": Show all children simultaneously when all are ready
 *   In Crank, the default behavior of async components is to render together,
 *   so "together" might not be necessary if you are not using <Suspense>
 *   fallbacks.
 *e@param tail - How to handle fallbacks:
 *   - "collapsed" (default): Show only the fallback for the next unresolved
 *     Suspense component
 *   - "hidden": Hide all fallbacks
 *   Tail behavior only applies when revealOrder is not "together".
 * @param timeout - Default timeout for Suspense children in milliseconds
 * @param children - The elements containing Suspense components to coordinate.
 *   Suspense components which are not rendered immediately (because they are
 *   the children of another async component) will not be coordinated.
 *
 * @example
 * ```jsx
 * <SuspenseList revealOrder="forwards" tail="collapsed">
 *   <Suspense fallback={<div>Loading A...</div>}>
 *     <ComponentA />
 *   </Suspense>
 *   <Suspense fallback={<div>Loading B...</div>}>
 *     <ComponentB />
 *   </Suspense>
 * </SuspenseList>
 * ```
 */
export declare function SuspenseList(this: Context, { revealOrder, tail, timeout, children, }: {
    revealOrder?: "forwards" | "backwards" | "together";
    tail?: "collapsed" | "hidden";
    timeout?: number;
    children: Children;
}): Generator<Children>;
export {};