import React from "react";
import * as ReactDOM from "react-dom/server";
import type { AppProps } from "./app.js";
import type { HeadOptions, TailOptions } from "./document.js";
/**
 * Headers sent to the server for the request.
 */
export interface Headers {
    get(name: string): string | null;
    getAll(name: string): string[];
    has(name: string): boolean;
}
/**
 * Parameters sent using form encoding to the server.
 */
export interface FormParams {
    get(name: string): string | null;
    getAll(name: string): string[];
    has(name: string): boolean;
}
/**
 * Standardized request format for server implementations.
 */
export interface Request {
    method: string;
    pathname: string;
    search: URLSearchParams;
    headers: Headers;
    form: () => Promise<FormParams>;
    text: () => Promise<string>;
    json: () => Promise<unknown>;
    arrayBuffer: () => Promise<ArrayBuffer>;
}
/**
 * Parameters provided from matching path segments, e.g. `/[param]`.
 */
export declare type Params = ReadonlyMap<string, string>;
/**
 * The request context used for server side functions.
 */
export interface ServerSideContext<C> {
    key: string;
    request: Request;
    params: Params;
    context: C;
    render: () => Promise<Response>;
    formData: object | undefined;
}
/**
 * Valid return type of `getServerSideProps`.
 */
export interface ServerSideProps<P> {
    props: P;
    hydrate?: boolean;
    status?: number;
    redirect?: {
        url: string;
    };
}
/**
 * Function signature for `getServerSideProps`.
 */
export declare type GetServerSideProps<P, C> = (context: ServerSideContext<C>) => ServerSideProps<P> | undefined | null;
/**
 * Stream rendering options.
 */
export interface StreamOptions {
    head?: string;
    tail?: string;
    onError?: (error: unknown) => void;
    signal?: AbortSignal;
    waitForAllReady?: boolean;
}
/**
 * Raw node.js stream result.
 */
export interface NodeStream {
    prefix: () => string;
    suffix: () => string;
    stream: ReactDOM.PipeableStream;
}
/**
 * Raw web stream result.
 */
export interface ReadableStream {
    prefix: () => Uint8Array;
    suffix: () => Uint8Array;
    stream: ReactDOM.ReactDOMServerReadableStream;
}
/**
 * Supported body interfaces.
 */
export interface Body {
    nodeStream(options?: StreamOptions): Promise<NodeStream>;
    readableStream(options?: StreamOptions): Promise<ReadableStream>;
}
/**
 * Simple `Response` interface for returning site pages.
 */
export interface Response {
    status: number;
    headers: ReadonlyMap<string, string>;
    body: Body | string | undefined;
}
/**
 * Handle all incoming requests to the current route.
 */
export declare type OnRequestHandler<C> = (context: ServerSideContext<C>, next: () => Promise<Response>) => Response | Promise<Response>;
/**
 * The server module page allows creation of loader and form handling.
 */
export interface PageServerModule<C> {
    getServerSideProps?: GetServerSideProps<{}, C>;
    onRequest?: Record<string, OnRequestHandler<C> | undefined>;
}
/**
 * The page component exports the component to be rendered as HTML.
 */
export interface PageModule {
    default?: React.ComponentType<{}>;
}
/**
 * The application module exports a react component that wraps every page.
 */
export interface AppModule {
    default?: React.ComponentType<AppProps>;
}
/**
 * The document module exports a function that returns the HTML header and footer.
 */
export interface DocumentModule {
    renderHead?: (options: HeadOptions) => string;
    renderTail?: (options: TailOptions) => string;
}
/**
 * Supported component loader input types (promises and functions).
 */
export declare type ServerLoader<T> = T | Promise<T> | (() => T | Promise<T>);
/**
 * Server-side only components.
 */
export interface ServerFile<T> {
    module: ServerLoader<T>;
}
/**
 * Server-side page component.
 */
export interface ServerPage<C> {
    module?: ServerLoader<PageModule>;
    serverModule?: ServerLoader<PageServerModule<C>>;
    scripts?: string[];
    css?: string[];
}
/**
 * Create a server instance from pages.
 */
export interface ServerOptions<C> {
    pages: Record<string, ServerPage<C>>;
    notFound?: ServerPage<C>;
    app?: ServerFile<AppModule>;
    document?: ServerFile<DocumentModule>;
}
/**
 * The server is just a `Request` in and `Response` out.
 */
export declare type Server<C> = (request: Request, context: C) => Promise<Response>;
/**
 * Create a simple SSR service given pages and apps.
 */
export declare function createServer<C>(options: ServerOptions<C>): Server<C>;
/**
 * Format JSON as response.
 */
export declare function json(json: unknown, status?: number): Response;
/**
 * Format redirect as a response.
 */
export declare function redirect(location: string, status?: number): Response;
/**
 * Handle form submission on the server-side.
 */
export declare type OnFormSubmitHandler<C> = (context: ServerSideContext<C>) => object | Promise<object>;
/**
 * Handle form submissions for `onRequest`.
 */
export declare function onFormSubmit<C>(process: OnFormSubmitHandler<C>): OnRequestHandler<C>;