import React from 'react';
import { createServerFn as createServerFn$1 } from '@tanstack/start-client-core';
export * from '@tanstack/start-client-core';
export * from '@tanstack/react-start';

type RequestOptions<TRegister = unknown> = {
    context?: TRegister extends {
        server: {
            requestContext: infer TRequestContext;
        };
    } ? TRequestContext : unknown;
};
type MockRequestExecutor<TRegister = unknown> = (request: Request, opts?: RequestOptions<TRegister>) => Promise<unknown> | unknown;
type HandlerContext = {
    request: Request;
    responseHeaders: Headers;
    router?: unknown;
    context?: unknown;
    requestContext?: unknown;
};
type HandlerCallback<TRouter = unknown> = (context: HandlerContext & {
    router?: TRouter;
}) => Promise<unknown> | unknown;
type SessionConfig = Record<string, unknown>;
type MockSession<TSessionData extends Record<string, unknown> = Record<string, unknown>> = {
    data: Partial<TSessionData>;
    update: (update?: Partial<TSessionData> | ((prev: Partial<TSessionData>) => Partial<TSessionData>)) => Promise<MockSession<TSessionData>>;
    save: () => Promise<void>;
    clear: () => Promise<void>;
};
declare const HEADERS: {
    readonly TSS_SHELL: "X-TSS_SHELL";
};
declare const VIRTUAL_MODULES: {
    readonly startManifest: "tanstack-start-manifest:v";
    readonly injectedHeadScripts: "tanstack-start-injected-head-scripts:v";
    readonly serverFnResolver: "#tanstack-start-server-fn-resolver";
};
declare function StartServer(): null;
declare const defineHandlerCallback: <TRouter = unknown>(handler: HandlerCallback<TRouter>) => HandlerCallback<TRouter>;
declare const defaultStreamHandler: () => Promise<Response>;
declare const defaultRenderHandler: () => Promise<Response>;
declare const requestHandler: <TRegister = unknown>(handler: MockRequestExecutor<TRegister>) => (request: Request, requestOpts?: RequestOptions<TRegister>) => Promise<Response>;
declare const createRequestHandler: <TRegister = unknown>(handler: MockRequestExecutor<TRegister>) => (request: Request, requestOpts?: RequestOptions<TRegister> | undefined) => Promise<Response>;
declare const createStartHandler: <TRegister = unknown>(cbOrOptions: HandlerCallback | {
    handler?: HandlerCallback;
}) => (request: Request, requestOpts?: RequestOptions<TRegister> | undefined) => Promise<Response>;
declare const attachRouterServerSsrUtils: <TRouter>(router: TRouter) => TRouter;
declare const transformReadableStreamWithRouter: <TReadableStream>(stream: TReadableStream) => TReadableStream;
declare const transformPipeableStreamWithRouter: <TPipeableStream>(stream: TPipeableStream) => TPipeableStream;
declare const getRequest: () => Request;
declare const getRequestHeaders: () => Headers;
declare const getRequestHeader: (name: string) => string | undefined;
declare const getRequestIP: (opts?: {
    xForwardedFor?: boolean;
}) => string | undefined;
declare const getRequestHost: (opts?: {
    xForwardedHost?: boolean;
}) => string;
declare const getRequestUrl: (opts?: {
    xForwardedHost?: boolean;
    xForwardedProto?: boolean;
}) => URL;
declare const getRequestProtocol: (opts?: {
    xForwardedProto?: boolean;
}) => string;
declare const setResponseHeaders: (headers: HeadersInit) => void;
declare const getResponseHeaders: () => Headers;
declare const getResponseHeader: (name: string) => string | undefined;
declare const setResponseHeader: (name: string, value: string | Array<string>) => void;
declare const removeResponseHeader: (name: string) => void;
declare const clearResponseHeaders: (headerNames?: Array<string>) => void;
declare const getResponseStatus: () => number;
declare const setResponseStatus: (code?: number, text?: string) => void;
declare const getCookies: () => {
    [k: string]: string;
};
declare const getCookie: (name: string) => string | undefined;
declare const setCookie: (name: string, value: string, options?: Record<string, unknown>) => void;
declare const deleteCookie: (name: string, options?: Record<string, unknown>) => void;
declare const useSession: <TSessionData extends Record<string, unknown> = Record<string, unknown>>(_config: SessionConfig) => Promise<MockSession<TSessionData>>;
declare const getSession: <TSessionData extends Record<string, unknown> = Record<string, unknown>>(_config: SessionConfig) => Promise<MockSession<TSessionData>>;
declare const updateSession: <TSessionData extends Record<string, unknown> = Record<string, unknown>>(_config: SessionConfig, update?: Partial<TSessionData> | ((prev: Partial<TSessionData>) => Partial<TSessionData>)) => Promise<MockSession<TSessionData>>;
declare const sealSession: (_config: SessionConfig) => Promise<string>;
declare const unsealSession: (_config: SessionConfig, sealed: string) => Promise<any>;
declare const clearSession: (_config: Partial<SessionConfig>) => Promise<void>;
declare const getResponse: () => {
    status: number | undefined;
    statusText: string | undefined;
    readonly headers: Headers;
};
declare const getValidatedQuery: (schema: {
    parse?: (value: Record<string, string>) => unknown;
    safeParse?: (value: Record<string, string>) => unknown;
    ["~standard"]?: {
        validate?: (value: Record<string, string>) => Promise<unknown> | unknown;
    };
}) => Promise<unknown>;
declare function useServerFn<T extends (...args: Array<any>) => Promise<any>>(serverFn: T): (...args: Parameters<T>) => ReturnType<T>;
declare const createServerFn: typeof createServerFn$1;
declare const Link: ({ to, children, ...props }: {
    to: string;
    children?: React.ReactNode;
    [key: string]: unknown;
}) => React.ReactElement<{
    href: string;
}, string | React.JSXElementConstructor<any>>;
declare const Navigate: ({ to }: {
    to: string;
}) => null;
declare const notFound: () => never;
declare const createStart: () => {};
declare const clearCookieStore: () => void;
declare const fetchHandler: () => Promise<Response>;

declare const _default: {
    fetch: () => Promise<Response>;
};

export { HEADERS, Link, Navigate, StartServer, VIRTUAL_MODULES, attachRouterServerSsrUtils, clearCookieStore, clearResponseHeaders, clearSession, createRequestHandler, createServerFn, createStart, createStartHandler, _default as default, defaultRenderHandler, defaultStreamHandler, defineHandlerCallback, deleteCookie, fetchHandler as fetch, getCookie, getCookies, getRequest, getRequestHeader, getRequestHeaders, getRequestHost, getRequestIP, getRequestProtocol, getRequestUrl, getResponse, getResponseHeader, getResponseHeaders, getResponseStatus, getSession, getValidatedQuery, notFound, removeResponseHeader, requestHandler, sealSession, setCookie, setResponseHeader, setResponseHeaders, setResponseStatus, transformPipeableStreamWithRouter, transformReadableStreamWithRouter, unsealSession, updateSession, useServerFn, useSession };