import { PropType } from "vue";
//#region src/utils/createHttpStatusSink.d.ts
/**
 * Render-scoped HTTP status sink. Created per request on the server, passed to
 * `<HttpStatusProvider :sink="...">`, and read after `renderToString` /
 * `renderToWebStream` to apply the value to the HTTP response.
 *
 * Last write wins: if the rendered tree mounts more than one
 * `<HttpStatusCode />`, the value reflects the last component that ran during
 * the render pass.
 *
 * No-op on the client — `<HttpStatusCode />` reads the optional injected sink
 * and skips the write when no provider is mounted, so the same component tree
 * can be hydrated without changing behaviour.
 *
 * Constraints:
 * - **Per-request only.** Don't share a sink across requests; the rendered
 *   tree mutates `code` in place. Module-level singletons leak status
 *   between concurrent requests.
 * - **Don't `Object.freeze` the sink.** The component writes to `.code`;
 *   freezing makes the assignment throw under ESM strict mode.
 * - **Hydration symmetry:** mount `<HttpStatusProvider>` on both server and
 *   client (with a throwaway client sink). Vue emits `<!--[-->` / `<!--]-->`
 *   fragment markers around the provider's slot; an extra provider on one
 *   side trips Vue with "Hydration completed but contains mismatches".
 */
interface HttpStatusSink {
  code: number | undefined;
}
export declare function createHttpStatusSink(): HttpStatusSink;
//#endregion
//#region src/components/ClientOnly.d.ts
export declare const ClientOnly: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>[] | undefined, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
type ClientOnlyProps = InstanceType<typeof ClientOnly>["$props"];
//#endregion
//#region src/components/ServerOnly.d.ts
export declare const ServerOnly: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>[] | undefined, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
type ServerOnlyProps = InstanceType<typeof ServerOnly>["$props"];
//#endregion
//#region src/components/Await.d.ts
/**
 * Reads `useDeferred(name)` and hands the resolved value to the `default`
 * scoped slot via Vue's native `async setup()` Suspense pattern. Wrap in
 * `<Streamed>` (or Vue's `<Suspense>`).
 *
 * ```vue-html
 * <Streamed>
 *   <Await name="reviews" v-slot="{ value }">
 *     <ReviewList :items="value" />
 *   </Await>
 *   <template #fallback>
 *     <Spinner />
 *   </template>
 * </Streamed>
 * ```
 *
 * Or with the render function:
 *
 * ```ts
 * h(Await, { name: "reviews" }, {
 *   default: ({ value }: { value: Review[] }) => h(ReviewList, { items: value }),
 * });
 * ```
 *
 * Implementation: `async setup()` awaits the deferred promise. Vue's
 * `<Suspense>` boundary catches the pending promise and shows the fallback
 * until resolution. Rejection bubbles to the nearest `onErrorCaptured`
 * handler.
 */
export declare const Await: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  /** Deferred key declared in the loader's `defer({ deferred: { <name>: ... } })`. */
  name: {
    type: StringConstructor;
    required: true;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>[] | undefined, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  /** Deferred key declared in the loader's `defer({ deferred: { <name>: ... } })`. */
  name: {
    type: StringConstructor;
    required: true;
  };
}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
type AwaitProps = InstanceType<typeof Await>["$props"];
//#endregion
//#region src/components/Streamed.d.ts
/**
 * Cross-adapter alias for Vue's native `<Suspense>`. Symmetric naming with
 * the React/Preact/Solid/Svelte/Angular `<Streamed>` components.
 *
 * Slots:
 * - `default` — content (may contain `<Await>` or `async setup()` children).
 * - `fallback` — shown while any descendant suspends.
 *
 * Vue's `<Suspense>` is **blocking** under SSR (no out-of-order placeholder
 * resolution) — render of HTML after `<Streamed>` waits for every
 * `async setup()` inside. This matches Vue 3's stable streaming behaviour
 * (vs React 19 / Solid which support OOO resolution).
 */
export declare const Streamed: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
type StreamedProps = InstanceType<typeof Streamed>["$props"];
//#endregion
//#region src/components/HttpStatusCode.d.ts
/**
 * Render-time HTTP status declaration. Mount inside a route component (typical
 * use case: a glob `*` route's NotFound page) when the status is decided by
 * the rendered tree rather than a loader.
 *
 * Writes `code` to the nearest `<HttpStatusProvider>`'s sink during `setup()`
 * and renders nothing. With no provider mounted (the standard client-side
 * case) the component is a silent no-op — same component tree hydrates
 * without touching the DOM or warning about mismatches.
 *
 * Loader-driven errors (`LoaderNotFound` → 404, `LoaderRedirect` → 30x) keep
 * working as before; this component covers render-time decisions only.
 *
 * Last write wins when several `<HttpStatusCode />` instances mount in the
 * same render pass — sink reflects the last component that ran.
 *
 * ```vue-html
 * <HttpStatusProvider :sink="sink">
 *   <RouterProvider :router="router">
 *     <App />
 *   </RouterProvider>
 * </HttpStatusProvider>
 *
 * <!-- inside NotFound.vue -->
 * <HttpStatusCode :code="404" />
 * ```
 *
 * **`renderToWebStream` (streaming SSR):** Vue 3 `<Suspense>` is
 * chunked-blocking — Vue waits for every `async setup()` inside a boundary
 * before emitting the chunks past it. So in practice `<HttpStatusCode />`
 * inside a `<Suspense>` boundary still writes to the sink before the
 * response headers flush. Still, prefer mounting in the shell to avoid
 * coupling the contract to that particular Vue 3 streaming behaviour. With
 * `renderToString` there is no ordering concern at all.
 *
 * **Hydration symmetry:** `<HttpStatusProvider>` wraps a render slot, so
 * Vue emits a fragment marker pair (`<!--[-->` / `<!--]-->`) around its
 * children server-side. Mount the same `<HttpStatusProvider>` on the
 * client (with a throwaway sink) to keep the marker count balanced — see
 * the `ssr/` example's `entry-client.ts`. Otherwise hydration logs
 * "Hydration completed but contains mismatches".
 *
 * **Valid `code` range:** Node's `res.end()` throws `Invalid status code`
 * on `NaN`, `0`, negative values, or values `> 999` — this surfaces as a
 * 5xx / dropped connection, not silent corruption. Pass a real HTTP status
 * integer (commonly 4xx/5xx; 100-999 is what Node accepts).
 */
export declare const HttpStatusCode: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  /** HTTP status to apply to the response. Common values: 404, 410, 451, 503. */
  code: {
    type: NumberConstructor;
    required: true;
  };
}>, () => null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  /** HTTP status to apply to the response. Common values: 404, 410, 451, 503. */
  code: {
    type: NumberConstructor;
    required: true;
  };
}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
type HttpStatusCodeProps = InstanceType<typeof HttpStatusCode>["$props"];
//#endregion
//#region src/components/HttpStatusProvider.d.ts
export declare const HttpStatusProvider: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  sink: {
    type: PropType<HttpStatusSink>;
    required: true;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>[] | undefined, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  sink: {
    type: PropType<HttpStatusSink>;
    required: true;
  };
}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
type HttpStatusProviderProps = InstanceType<typeof HttpStatusProvider>["$props"];
//#endregion
//#region src/composables/useDeferred.d.ts
/**
 * Read a deferred promise published by `defer({ deferred: { <key>: Promise } })`
 * inside an SSR data loader. Returns the Promise for use inside `async setup()`
 * (Vue's native Suspense pattern) or paired with `<Await name="key">`.
 *
 * ```ts
 * // Vue async setup pattern
 * export default defineComponent({
 *   async setup() {
 *     const reviews = await useDeferred<Review[]>("reviews");
 *     return () => h("div", reviews.map(...));
 *   },
 * });
 * ```
 *
 * Returns a forever-pending promise when the key is missing — surfaces
 * loader/consumer key drift as a visible Suspense fallback rather than a
 * silent runtime error.
 */
export declare function useDeferred<T = unknown>(key: string): Promise<T>;
//#endregion
export type { AwaitProps, ClientOnlyProps, HttpStatusCodeProps, HttpStatusProviderProps, HttpStatusSink, ServerOnlyProps, StreamedProps };
//# sourceMappingURL=ssr.d.ts.map