import { c as Props, t as Children } from "./children-s3nFjpLA.mjs";

//#region src/await.d.ts
/** @internal Metadata stamped on an Await region getter (see claim walk). */
interface AsyncRegionMeta {
  /** ek-data ids the server consumed for this region. */
  ids: number;
  /** True while any of the region's awaitables is pending. */
  pending(): boolean;
}
/**
 * Loading boundary for async children — elements-kit's `Suspense` equivalent.
 *
 * Direct async children (`promise`/`async` values — including the
 * code-splitting pattern `async(() => import("./chart"))`) are detected
 * automatically; pass `when` to gate on arbitrary awaitables instead. While
 * anything is pending the client renders `fallback`; once everything settles
 * the children show. The server never renders the fallback — the stream
 * awaits and emits the real content. During hydration the server content
 * stays visible while the region is pending (no fallback flash).
 *
 * Prefer a thunk fallback (`fallback={() => <Spinner/>}`) so it renders
 * fresh each time the boundary re-enters a pending state.
 *
 * @example Code splitting with `async` + dynamic import:
 * ```tsx
 * const chart = async(() => import("./chart").then((m) => m.default));
 *
 * function Panel() {
 *   chart.run(); // server: awaited · hydration: deferred · client: import
 *   return (
 *     <Await fallback={() => <em>loading…</em>}>{chart}</Await>
 *   );
 * }
 * ```
 *
 * @example Passing props to a code-split component:
 * ```tsx
 * const chart = async(() => import("./chart").then((m) => m.default));
 * chart.run();
 *
 * <Await fallback={() => <em>loading…</em>}>
 *   {promise(chart.then((C) => () => <C data={data} />))}
 * </Await>
 * ```
 */
type AwaitChildren = Children | PromiseLike<Children> | (Children | PromiseLike<Children>)[];
declare function Await(props: Props<{
  fallback?: Children;
  when?: unknown;
  children?: AwaitChildren;
}>): Element;
//#endregion
export { AsyncRegionMeta, Await };