/// <reference types="node" />
import { Server } from 'node:net';
import { CompressionOptions } from 'compression';
import { Express, Request } from 'express';
import { Response as ExpressResponse } from "express";
import { FC, PropsWithChildren } from 'react';
import { createStaticHandler } from 'react-router';
import { ServeStaticOptions } from 'serve-static';
import { Logger } from 'vite';
import { TRouteObject } from "../interfaces/route-object.js";
import { IRenderOptions, TRender } from "./render.js";
import ServerApi from "../services/server-api.js";
import ServerConfig from "../services/server-config.js";
interface IInitServerRequestOut<T = Record<string, any>> {
    appProps?: T;
    hasEarlyHints?: boolean;
    shouldSkip?: boolean;
    shouldCancel?: boolean;
}
interface IEntrypointOptions<TAppProps = Record<string, any>> {
    onServerCreated?: (app: Express, serverApi: ServerApi) => Promise<void> | void;
    onServerStarted?: (app: Express, serverApi: ServerApi, server: Server) => Promise<void> | void;
    onRequest?: (req: Request, res: ExpressResponse) => Promise<IInitServerRequestOut<TAppProps>> | IInitServerRequestOut<TAppProps>;
    onRouterReady?: IRenderOptions<TAppProps>['onRouterReady'];
    onShellReady?: IRenderOptions<TAppProps>['onShellReady'];
    onShellError?: IRenderOptions<TAppProps>['onShellError'];
    onResponse?: IRenderOptions<TAppProps>['onResponse'];
    onError?: IRenderOptions<TAppProps>['onError'];
    getState?: IRenderOptions<TAppProps>['getState'];
}
interface IPrepareRenderOut<TAppProps = Record<string, any>> {
    render: TRender;
    init: IEntryServerOptions<TAppProps>['init'];
    routes: TRouteObject[];
    abortDelay?: number;
    loggerProd?: Logger;
    loggerDev?: Logger;
    middlewares?: {
        compression?: CompressionOptions | false;
        expressStatic?: (ServeStaticOptions & {
            basename?: string;
        }) | false;
    };
}
interface IAppServerProps<T = Record<string, any>> {
    server: T;
}
type TApp<T> = FC<PropsWithChildren<Record<string, any> & IAppServerProps<T>>>;
interface IEntryServerOptions<TAppProps = Record<string, any>> {
    abortDelay?: number;
    init?: (params: {
        config: ServerConfig;
    }) => IEntrypointOptions<TAppProps> | Promise<IEntrypointOptions<TAppProps>>;
    loggerProd?: IPrepareRenderOut['loggerProd'];
    loggerDev?: IPrepareRenderOut['loggerDev'];
    middlewares?: IPrepareRenderOut['middlewares'];
    routerOptions?: Parameters<typeof createStaticHandler>[1];
}
/**
 * Render server side application
 */
declare function entry<TAppProps>(App: TApp<TAppProps>, routes: TRouteObject[], { init, routerOptions, ...rest }?: IEntryServerOptions<TAppProps>): IPrepareRenderOut<TAppProps>;
export { entry as default, IInitServerRequestOut, IEntrypointOptions, IPrepareRenderOut, IAppServerProps, TApp, IEntryServerOptions };