@stone-js/use-react 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1566 @@
+import { HTMLMetaDescriptor, HeadContext as HeadContext$1, FunctionalEventHandler, Route, Router, DecoratorPageRouteDefinition, NavigateOptions } from '@stone-js/router';
+import * as react from 'react';
+import { ReactNode, ElementType, FunctionComponent } from 'react';
+import { Config } from '@stone-js/config';
+import { BrowserEvent, BrowserResponse, BrowserContext, BrowserAdapterResponseBuilder } from '@stone-js/browser-adapter';
+import { IncomingHttpEvent, OutgoingHttpResponse, RedirectResponse, IncomingHttpEventOptions, OutgoingHttpResponseOptions, RedirectResponseOptions } from '@stone-js/http-core';
+import { IncomingBrowserEvent, OutgoingBrowserResponse, RedirectBrowserResponse, IncomingBrowserEventOptions, OutgoingBrowserResponseOptions, RedirectBrowserResponseOptions } from '@stone-js/browser-core';
+import { IContainer, Promiseable, Laziable, FunctionalErrorHandler, IBlueprint, FunctionalAdapterErrorHandler, OutgoingResponseOptions, HookName as HookName$1, LifecycleHookType, ErrorHandlerOptions, AdapterErrorHandlerOptions, AdapterContext, IAdapterErrorHandler, AdapterErrorContext, AdapterEventBuilderType, IEventHandler, IErrorHandler, ILogger, IServiceProvider, StoneBlueprint, AppConfig, ClassType, InitializationError, ErrorOptions, BlueprintContext, NextMiddleware, MetaMiddleware } from '@stone-js/core';
+import { Root } from 'react-dom/client';
+
+/**
+  * Stone DOM Attribute.
+  */
+declare const STONE_DOM_ATTR = "data-stone-head";
+/**
+ * Apply meta tags to the document document.head.
+ *
+ * @param document - The document object.
+ * @param meta - The meta tag descriptor.
+ */
+declare const applyMeta: (document: Document, meta: HTMLMetaDescriptor) => void;
+/**
+ * Apply the head context to the document document.head.
+ *
+ * @param document - The document object.
+ * @param context - The head context containing meta, link, script, and style descriptors.
+ */
+declare const applyHeadContextToDom: (document: Document, context: HeadContext$1) => void;
+/**
+ * Escape HTML special characters in a string.
+ *
+ * @param context - The head context containing meta, link, script, and style descriptors.
+ * @param html - The HTML string to escape.
+ * @returns The escaped string.
+ */
+declare const applyHeadContextToHtmlString: (context: HeadContext$1, html: string) => string;
+
+/**
+ * The type representing the Head Context for React.
+ * It extends the BaseHeadContext to include additional properties specific to React.
+ * This type is used to manage the head elements of a React application.
+*/
+type HeadContext = HeadContext$1;
+/**
+ * The type representing a Snapshot.
+ * An object that represents the state of the application at a given time.
+*/
+type ISnapshot = Config;
+/**
+ * Route for React.
+*/
+type IRoute = Route<ReactIncomingEvent, ReactOutgoingResponse>;
+/**
+ * Router for React.
+*/
+type IRouter = Router<ReactIncomingEvent, ReactOutgoingResponse>;
+/**
+ * Headers type for React.
+ */
+type HeadersType = Headers | Map<string, string | string[]> | Record<string, string | string[]>;
+/**
+ * Incoming event for React.
+*/
+type ReactIncomingEvent = IncomingHttpEvent | IncomingBrowserEvent;
+/**
+ * Incoming event options for React.
+*/
+type ReactIncomingEventOptions = IncomingBrowserEventOptions | IncomingHttpEventOptions;
+/**
+ * Outgoing response for React.
+*/
+type ReactOutgoingResponse = (OutgoingHttpResponse | OutgoingBrowserResponse | RedirectResponse | RedirectBrowserResponse) & {
+    content: any;
+};
+/**
+ * Options for creating a React Outgoing Response.
+*/
+interface ReactOutgoingResponseOptions extends OutgoingResponseOptions {
+    headers?: HeadersType;
+}
+/**
+ * UseReactHookName Type.
+ */
+type UseReactHookName = 'onPreparingPage';
+/**
+ * HookName Type.
+ *
+ * extends Core HookName.
+ */
+type HookName = HookName$1 | UseReactHookName;
+/**
+ * Use React Hook Listener Context.
+ */
+interface UseReactHookListenerContext {
+    data: any;
+    error?: any;
+    head?: HeadContext;
+    container: IContainer;
+    componentType: unknown;
+    event: ReactIncomingEvent;
+    snapshot: ResponseSnapshotType;
+    response: ReactOutgoingResponse;
+}
+/**
+ * UseReactHookListener Type.
+ *
+ * Represents a listener hook that can either be synchronous or asynchronous.
+ */
+type UseReactHookListener = (context: UseReactHookListenerContext) => Promiseable<void>;
+/**
+ * UseReactHook Type.
+ */
+interface UseReactHookType {
+    onPreparingPage?: UseReactHookListener[];
+}
+/**
+ * ReactLifecycleHookType Type.
+ */
+type ReactLifecycleHookType = LifecycleHookType<IBlueprint, any, any, ReactIncomingEvent, any> & UseReactHookType;
+/**
+ * Options for configuring the `Page` decorator.
+ * Extends `PageRouteDefinition` but excludes the `methods` property,
+ * as it is predefined as `'GET'` by the decorator.
+ */
+interface PageOptions extends DecoratorPageRouteDefinition {
+    layout?: string;
+    headers?: HeadersType;
+}
+/**
+ * Options for configuring the `PageLayout` decorator.
+ */
+interface PageLayoutOptions {
+    name?: 'default' | string;
+}
+/**
+ * Options for configuring the `ErrorPage` decorator.
+ */
+interface ErrorPageOptions extends ErrorHandlerOptions {
+    layout?: string;
+}
+/**
+ * Options for configuring the `AdapterErrorPage` decorator.
+ */
+interface AdapterErrorPageOptions extends AdapterErrorHandlerOptions {
+    layout?: string;
+}
+/**
+ * Browser Adapter Context for React.
+ */
+type ReactBrowserAdapterContext = AdapterContext<BrowserEvent, BrowserResponse, BrowserContext, IncomingBrowserEvent, IncomingBrowserEventOptions, OutgoingBrowserResponse>;
+/**
+ * Stone data snapshot type.
+ */
+interface ResponseSnapshotType {
+    data?: any;
+    error?: any;
+    ssr: boolean;
+    layout?: unknown;
+    statusCode?: number;
+}
+/**
+ * Browser response content for React.
+ */
+interface BrowserResponseContent {
+    ssr?: boolean;
+    app?: ReactNode;
+    head?: HeadContext;
+    fullRender?: boolean;
+    component?: ReactNode;
+    targetUrl?: string | URL;
+}
+/**
+ * Context for React.
+ */
+interface StoneContextType {
+    data: any;
+    container: IContainer;
+    event: ReactIncomingEvent;
+}
+/**
+ * React page render context.
+ */
+interface PageRenderContext<TData = any> {
+    data?: TData;
+    statusCode?: number;
+    container: IContainer;
+    event: ReactIncomingEvent;
+}
+/**
+ * React page head context.
+ */
+interface PageHeadContext<TData = any> {
+    data?: TData;
+    statusCode?: number;
+    event: ReactIncomingEvent;
+}
+/**
+ * Represents a page class.
+ *
+ * @template IncomingEventType - The type representing the incoming event.
+ * @template OutgoingResponseType - The type representing the outgoing response.
+*/
+type PageClass<IncomingEventType extends ReactIncomingEvent, OutgoingResponseType = unknown> = new (...args: any[]) => IPage<IncomingEventType, OutgoingResponseType>;
+/**
+ * Represents a page.
+ *
+ * @template IncomingEventType - The type representing the incoming event.
+ * @template OutgoingResponseType - The type representing the outgoing response.
+*/
+interface IPage<IncomingEventType extends ReactIncomingEvent, OutgoingResponseType = unknown> {
+    render: (context: PageRenderContext<any>) => ReactNode;
+    handle?: FunctionalEventHandler<IncomingEventType, OutgoingResponseType>;
+    head?: (context: PageHeadContext<any>) => Promiseable<HeadContext>;
+}
+/**
+ * Represents a factory page.
+ *
+ * @template IncomingEventType - The type representing the incoming event.
+ * @template OutgoingResponseType - The type representing the outgoing response.
+*/
+type FactoryPage<IncomingEventType extends ReactIncomingEvent, OutgoingResponseType = unknown> = (container?: IContainer | any) => IPage<IncomingEventType, OutgoingResponseType>;
+/**
+ * Represents a page type.
+ *
+ * @template IncomingEventType - The type representing the incoming event.
+ * @template OutgoingResponseType - The type representing the outgoing response.
+ */
+type PageType<IncomingEventType extends ReactIncomingEvent, OutgoingResponseType = unknown> = PageClass<IncomingEventType, OutgoingResponseType> | FactoryPage<IncomingEventType, OutgoingResponseType>;
+/**
+ * Represents a meta page.
+ *
+ * @template IncomingEventType - The type representing the incoming event.
+ * @template OutgoingResponseType - The type representing the outgoing response.
+ */
+interface MetaPage<IncomingEventType extends ReactIncomingEvent, OutgoingResponseType = unknown> {
+    lazy?: boolean;
+    layout?: unknown;
+    isClass?: boolean;
+    isFactory?: boolean;
+    isComponent?: boolean;
+    module: PageType<IncomingEventType, OutgoingResponseType> | Laziable<PageType<IncomingEventType, OutgoingResponseType>>;
+}
+/**
+ * React render page layout options.
+ */
+interface PageLayoutRenderContext {
+    children: ReactNode;
+    container: IContainer;
+}
+/**
+ * React render page layout options.
+ */
+interface AdapterPageLayoutRenderContext {
+    children: ReactNode;
+    blueprint: IBlueprint;
+}
+/**
+ * Represents a Page layout class.
+*/
+type PageLayoutClass = new (...args: any[]) => IPageLayout;
+/**
+ * Represents a Page layout.
+*/
+interface IPageLayout {
+    head?: () => Promiseable<HeadContext>;
+    render: (context: PageLayoutRenderContext | AdapterPageLayoutRenderContext | any) => ReactNode;
+}
+/**
+ * Represents a factory page layout.
+*/
+type FactoryPageLayout = (container?: IContainer | any) => IPageLayout;
+/**
+ * Represents a page layout type.
+ */
+type PageLayoutType = PageLayoutClass | FactoryPageLayout;
+/**
+ * Represents a meta page layout.
+ */
+interface MetaPageLayout {
+    lazy?: boolean;
+    isClass?: boolean;
+    isFactory?: boolean;
+    module: PageLayoutType | Laziable<PageLayoutType>;
+}
+/**
+ * React error page render context.
+ */
+interface ErrorPageRenderContext<TError = any, UData = any> extends PageRenderContext<UData> {
+    error: TError;
+}
+/**
+ * React error page head context.
+ */
+interface ErrorPageHeadContext<TError = any, UData = any> extends PageHeadContext<UData> {
+    error: TError;
+}
+/**
+ * Represents an error page class.
+ *
+ * @template IncomingEventType - The type representing the incoming event.
+ * @template OutgoingResponseType - The type representing the outgoing response.
+*/
+type ErrorPageClass<IncomingEventType extends ReactIncomingEvent, OutgoingResponseType = unknown> = new (...args: any[]) => IErrorPage<IncomingEventType, OutgoingResponseType>;
+/**
+ * Represents an error page.
+ *
+ * @template IncomingEventType - The type representing the incoming event.
+ * @template OutgoingResponseType - The type representing the outgoing response.
+*/
+interface IErrorPage<IncomingEventType extends ReactIncomingEvent, OutgoingResponseType = unknown> {
+    handle?: FunctionalErrorHandler<IncomingEventType, OutgoingResponseType>;
+    render: (context: ErrorPageRenderContext<any, any>) => ReactNode;
+    head?: (context: ErrorPageHeadContext<any, any>) => Promiseable<HeadContext>;
+}
+/**
+ * Represents a factory error page.
+ *
+ * @template IncomingEventType - The type representing the incoming event.
+ * @template OutgoingResponseType - The type representing the outgoing response.
+*/
+type FactoryErrorPage<IncomingEventType extends ReactIncomingEvent, OutgoingResponseType = unknown> = (container?: IContainer | any) => IErrorPage<IncomingEventType, OutgoingResponseType>;
+/**
+ * Represents an error page type.
+ *
+ * @template IncomingEventType - The type representing the incoming event.
+ * @template OutgoingResponseType - The type representing the outgoing response.
+ */
+type ErrorPageType<IncomingEventType extends ReactIncomingEvent, OutgoingResponseType = unknown> = ErrorPageClass<IncomingEventType, OutgoingResponseType> | FactoryErrorPage<IncomingEventType, OutgoingResponseType>;
+/**
+ * Represents a meta error page.
+ *
+ * @template IncomingEventType - The type representing the incoming event.
+ * @template OutgoingResponseType - The type representing the outgoing response.
+ */
+interface MetaErrorPage<IncomingEventType extends ReactIncomingEvent, OutgoingResponseType = unknown> {
+    error?: any;
+    lazy?: boolean;
+    layout?: unknown;
+    isClass?: boolean;
+    isFactory?: boolean;
+    module: ErrorPageType<IncomingEventType, OutgoingResponseType> | Laziable<ErrorPageType<IncomingEventType, OutgoingResponseType>>;
+}
+/** ****** Adapter Error page *************/
+/**
+ * React Adapter render page error options.
+ */
+interface AdapterErrorPageRenderContext<TError = any> {
+    error: TError;
+    statusCode: number;
+    blueprint: IBlueprint;
+}
+/**
+ * Represents an Adapter component error handler class.
+*/
+type AdapterErrorPageClass<RawEventType, RawResponseType, ExecutionContextType> = new (...args: any[]) => IAdapterErrorPage<RawEventType, RawResponseType, ExecutionContextType>;
+/**
+ * Represents an Adapter component error handler.
+*/
+interface IAdapterErrorPage<RawEventType, RawResponseType, ExecutionContextType> {
+    handle?: FunctionalAdapterErrorHandler<RawEventType, RawResponseType, ExecutionContextType>;
+    render: (context: AdapterErrorPageRenderContext<any>) => ReactNode;
+}
+/**
+ * Represents an Adapter factory component error handler.
+*/
+type FactoryAdapterErrorPage<RawEventType, RawResponseType, ExecutionContextType> = (container?: IContainer | any) => IAdapterErrorPage<RawEventType, RawResponseType, ExecutionContextType>;
+/**
+ * Represents an Adapter component error handler type.
+ */
+type AdapterErrorPageType<RawEventType, RawResponseType, ExecutionContextType> = AdapterErrorPageClass<RawEventType, RawResponseType, ExecutionContextType> | FactoryAdapterErrorPage<RawEventType, RawResponseType, ExecutionContextType>;
+/**
+ * Represents an Adapter meta component error handler.
+ */
+interface MetaAdapterErrorPage<RawEventType, RawResponseType, ExecutionContextType> {
+    error?: any;
+    lazy?: boolean;
+    layout?: unknown;
+    platform?: string;
+    isClass?: boolean;
+    isFactory?: boolean;
+    adapterAlias?: string;
+    module: AdapterErrorPageType<RawEventType, RawResponseType, ExecutionContextType> | Laziable<AdapterErrorPageType<RawEventType, RawResponseType, ExecutionContextType>>;
+}
+
+/**
+ * ReactRuntimeOptions
+*/
+interface ReactRuntimeOptions {
+    snapshot: ISnapshot;
+    blueprint: IBlueprint;
+    container: IContainer;
+}
+/**
+ * Class representing a ReactRuntime.
+ *
+ * This class is responsible for handling the React runtime environment,
+ * including create snapshots and managing errors.
+*/
+declare class ReactRuntime {
+    private readonly _snapshot;
+    private readonly container;
+    private readonly blueprint;
+    /**
+     * The ReactRuntime instance.
+     *
+     * @type {ReactRuntime}
+     */
+    static instance?: ReactRuntime;
+    /**
+     * Create a ReactRuntime.
+     *
+     * @param options - ReactRuntime options.
+    */
+    constructor({ container, blueprint, snapshot }: ReactRuntimeOptions);
+    /**
+     * Create a snapshot.
+     *
+     * This method will create a snapshot of the current event.
+     * If the environment is server, it will create a snapshot.
+     * If the environment is client, it will return the snapshot.
+     *
+     * @param key - The key to store the snapshot.
+     * @param handler - The handler to create the snapshot.
+     * @returns The snapshot value.
+    */
+    snapshot<T>(key: string, handler: (container?: IContainer) => Promiseable<T>): Promise<T>;
+    /**
+     * Set html head tags.
+     *
+     * This method will set the head elements in the document.
+     *
+     * @param value - The head context to set.
+     */
+    head(value: HeadContext$1): void;
+    /**
+     * Throw an error.
+     *
+     * This method will handle the error and render the error component.
+     * If no error handler is found, the error will be thrown.
+     *
+     * @param error - The error to throw.
+     * @param statusCode - The status code to return.
+     * @returns void
+     * @throws error
+    */
+    throwError(error: any, statusCode?: number): Promise<void>;
+    /**
+     * Render an error component.
+     *
+     * This method will render the error component.
+     *
+     * @param error - The error to render.
+     * @param metavalue - The meta value to render.
+     * @param statusCode - The status code to return.
+     * @returns void
+    */
+    private renderErrorComponent;
+}
+/**
+ * MetaReactRuntime
+*/
+declare const MetaReactRuntime: {
+    module: typeof ReactRuntime;
+    isClass: boolean;
+    alias: string;
+    singleton: boolean;
+};
+
+/**
+ * UseReactBrowserErrorHandler options.
+ */
+interface UseReactBrowserErrorHandlerOptions {
+    blueprint: IBlueprint;
+}
+/**
+ * Class representing an UseReactBrowserErrorHandler.
+ *
+ * Adapter level error handler for React applications.
+ */
+declare class UseReactBrowserErrorHandler implements IAdapterErrorHandler<unknown, unknown, unknown> {
+    private readonly logger;
+    private readonly blueprint;
+    /**
+     * Create an UseReactBrowserErrorHandler.
+     *
+     * @param options - UseReactBrowserErrorHandler options.
+     */
+    constructor({ blueprint }: UseReactBrowserErrorHandlerOptions);
+    /**
+     * Handle an error.
+     *
+     * @param error - The error to handle.
+     * @param context - The context of the adapter.
+     * @returns The raw response.
+     */
+    handle(error: any, context: AdapterErrorContext<unknown, unknown, unknown>): Promise<AdapterEventBuilderType<unknown>>;
+    /**
+     * Get the error body.
+     *
+     * @param error - The error to handle.
+     * @returns The error body.
+     */
+    private renderError;
+}
+
+/**
+ * Stone context.
+ * Usefull to pass data to the components.
+ */
+declare const StoneContext: react.Context<StoneContextType>;
+
+/**
+ * A useReact event handler for processing incoming events
+ * For single event handler.
+ *
+ * Multiple event handlers will be processed by the router.
+ *
+ * @template IncomingEventType - The type representing the incoming event.
+ * @template OutgoingResponseType - The type representing the outgoing response.
+ */
+declare class UseReactEventHandler<IncomingEventType extends ReactIncomingEvent = ReactIncomingEvent> implements IEventHandler<IncomingEventType, MetaPage<IncomingEventType>> {
+    private readonly blueprint;
+    /**
+     * Constructs a `UseReactEventHandler` instance.
+     *
+     * @param options - The UseReactEventHandler options including blueprint.
+     */
+    constructor({ blueprint }: {
+        blueprint: IBlueprint;
+    });
+    /**
+     * Handle an incoming event.
+     *
+     * @returns The outgoing response.
+     */
+    handle(): MetaPage<IncomingEventType>;
+    /**
+     * Get the component event handler.
+     *
+     * @returns The component event handler.
+     * @throws {UseReactError} If the component event handler is missing.
+     */
+    private getComponentEventHandler;
+}
+
+/**
+ * UseReactError response type.
+ */
+type UseReactErrorResponseType = Record<'content' | 'statusCode', Partial<MetaErrorPage<ReactIncomingEvent>> | number>;
+/**
+ * Class representing an UseReactUseReactKernelErrorHandler.
+ *
+ * Kernel level error handler for React applications.
+ */
+declare class UseReactKernelErrorHandler implements IErrorHandler<ReactIncomingEvent, UseReactErrorResponseType> {
+    private readonly blueprint;
+    /**
+     * Create an UseReactUseReactKernelErrorHandler.
+     *
+     * @param options - UseReactUseReactKernelErrorHandler options.
+     */
+    constructor({ blueprint }: {
+        blueprint: IBlueprint;
+    });
+    /**
+     * Handle an error.
+     *
+     * @param error - The error to handle.
+     * @returns The outgoing http response.
+     */
+    handle(error: any): UseReactErrorResponseType;
+}
+
+/**
+ * Options for onPreparingResponse hook.
+ */
+interface OnPreparingResponseOptions {
+    container: IContainer;
+    event: IncomingBrowserEvent;
+    response: ReactOutgoingResponse;
+}
+/**
+ * Hook that runs just before preparing the response.
+ *
+ * @param context - The context of the hook.
+*/
+declare function onPreparingResponse({ event, response, container }: OnPreparingResponseOptions): Promise<void>;
+
+/**
+ * Build the React application for the current route.
+ * Or for the main handler if the route is not defined.
+ *
+ * @param event - ReactIncomingEvent
+ * @param container - Service Container
+ * @param component - The component response.
+ * @param layout - The layout response.
+ * @param data - The data to pass to the component.
+ * @returns The resolved ReactNode.
+ */
+declare const buildAppComponent: (event: ReactIncomingEvent, container: IContainer, component?: ElementType, layout?: unknown, data?: any, statusCode?: number, error?: any) => Promise<ReactNode>;
+/**
+ * Get response layout in the current route for mutli pages application.
+ * Or get it from the blueprint configuration for single page application.
+ * Or get the default layout defined by the user.
+ * If not defined, return undefined.
+ *
+ * @param container - Service Container.
+ * @param children - The children to render.
+ * @param layoutName - The layout name.
+ * @returns The resolved layout element.
+ */
+declare const buildLayoutComponent: (container: IContainer, children: ReactNode, layoutName?: unknown) => Promise<ReactNode | undefined>;
+/**
+ * Get response component in the current route.
+ * If not defined, return an empty object.
+ *
+ * @param event - ReactIncomingEvent
+ * @param container - Service Container
+ * @param component - The component response.
+ * @param data - The data to pass to the component.
+ * @param statusCode - The status code of the error.
+ * @param error - The error object.
+ * @returns The resolved component element.
+ */
+declare const buildPageComponent: (event: ReactIncomingEvent, container: IContainer, component?: ElementType, data?: any, statusCode?: number, error?: any) => ReactNode;
+/**
+ * Get adapter error component.
+ *
+ * This error handler is different from the kernel error handler.
+ * Because there is no container at adapter level.
+ *
+ * @param blueprint - The blueprint.
+ * @param context - The context of the adapter.
+ * @param statusCode - The status code of the error.
+ * @param error - The error object.
+ * @returns The resolved layout element.
+ */
+declare const buildAdapterErrorComponent: <RawEventType, RawResponseType, ExecutionContextType>(blueprint: IBlueprint, context: AdapterErrorContext<RawEventType, RawResponseType, ExecutionContextType>, statusCode: number, error: any) => Promise<ReactNode | undefined>;
+/**
+ * Resolve the event handler for the component.
+ *
+ * Can also resolve dynamically loaded components.
+ *
+ * @param container - The service container.
+ * @param metaComponent - The meta component event handler.
+ * @returns The resolved element type.
+ */
+declare const resolveComponent: <T = IPage<ReactIncomingEvent> | IErrorPage<ReactIncomingEvent> | IPageLayout>(container: IContainer, metaComponent?: MetaPage<ReactIncomingEvent> | MetaErrorPage<ReactIncomingEvent> | MetaPageLayout) => Promise<T | undefined>;
+/**
+ * Resolve lazy loaded components.
+ *
+ * @param metaComponent - The meta component event handler.
+ * @returns The resolved element type.
+ */
+declare const resolveLazyComponent: (metaComponent?: MetaPageLayout | MetaPage<ReactIncomingEvent> | MetaErrorPage<ReactIncomingEvent> | MetaAdapterErrorPage<any, any, any>) => Promise<MetaPageLayout | MetaPage<ReactIncomingEvent> | MetaErrorPage<ReactIncomingEvent> | MetaAdapterErrorPage<any, any, any> | undefined>;
+/**
+ * Get the root element to render the React components.
+ *
+ * @param blueprint - The blueprint.
+ * @returns The root element to render the React components.
+ * @throws {UseReactError} If the root container is not found.
+ */
+declare const getAppRootElement: (blueprint: IBlueprint) => HTMLElement;
+/**
+ * Renders the React app.
+ *
+ * @param app - The React app to render.
+ * @param blueprint - The blueprint.
+ * @returns The React root instance.
+ */
+declare const renderReactApp: (app: ReactNode, blueprint: IBlueprint) => Root;
+/**
+ * Hydrates the React app when SSR is enabled.
+ *
+ * @param app - The React app to hydrate.
+ * @param blueprint - The blueprint.
+ * @returns The React root instance.
+ */
+declare const hydrateReactApp: (app: ReactNode, blueprint: IBlueprint) => Root;
+/**
+ * Check if the current environment is the server.
+ *
+ * @returns True if the current environment is the server.
+ */
+declare const isServer: () => boolean;
+/**
+ * Check if the current environment is the client.
+ *
+ * @returns True if the current environment is the client.
+ */
+declare const isClient: () => boolean;
+/**
+ * Get the HTML template for the React application.
+ *
+ * @param blueprint - The blueprint.
+ * @returns The HTML template.
+ */
+declare const htmlTemplate: (blueprint: IBlueprint) => string;
+/**
+ * Determine if the application is running on the server side.
+ *
+ * @returns True if the application is running on the server side, false otherwise.
+ */
+declare function isSSR(): boolean;
+/**
+ * Execute the handler.
+ *
+ * This method will try to get data from the snapshot
+ * If the snapshot is not present, it will execute the handler.
+ * If the handler is not present, it will return undefined.
+ *
+ * @param response - The response object.
+ * @returns The data from the response.
+ */
+declare function executeHandler(event: IncomingBrowserEvent, response: ReactOutgoingResponse, snapshot: ResponseSnapshotType, handler?: (IPage<IncomingBrowserEvent> | IErrorPage<IncomingBrowserEvent>), error?: any): Promise<any>;
+/**
+ * Get the browser content.
+ *
+ * @param app - The app component to render.
+ * @param component - The component to render.
+ * @param layout - The layout to use.
+ * @param snapshot - The response snapshot.
+ * @param head - The head context.
+ * @returns The browser response content.
+ */
+declare function getBrowserContent(app: ReactNode, component: ReactNode, layout: any, snapshot: ResponseSnapshotType, head?: HeadContext): BrowserResponseContent;
+/**
+ * Get the server content.
+ *
+ * @param component - The React component to hydrate.
+ * @param data - The data to pass to the components.
+ * @param container - The service container.
+ * @param event - The incoming browser event.
+ * @param head - The head context.
+ * @returns A promise that resolves when the content is hydrated.
+ */
+declare function getServerContent(component: ReactNode, data: Partial<ResponseSnapshotType>, container: IContainer, event: IncomingBrowserEvent, head?: HeadContext): Promise<string>;
+/**
+ * Get the response snapshot.
+ *
+ * @param event - The incoming browser event.
+ * @returns The response snapshot.
+ */
+declare function getResponseSnapshot(event: IncomingBrowserEvent, container: IContainer): ResponseSnapshotType;
+/**
+ * Snapshot the response data.
+ *
+ * @param event - The incoming HTTP event.
+ * @param data - The data to snapshot.
+ */
+declare function snapshotResponse(event: IncomingBrowserEvent, container: IContainer, data: Partial<ResponseSnapshotType>): string;
+/**
+ * Render Stone snapshot.
+ *
+ * @param snapshot - The snapshot to render.
+ * @returns The script tag.
+ */
+declare function renderStoneSnapshot(snapshot: string): string;
+/**
+ * Execute hooks.
+ *
+ * @param name - The name of the hook.
+ * @param context - The context of the adapter.
+ */
+declare function executeHooks(name: UseReactHookName, context: UseReactHookListenerContext): Promise<void>;
+
+/**
+ * Prepare the page to render.
+ *
+ * Here we prepare the page to render by resolving
+ * the handler, handler the event, and rendering the component.
+ *
+ * @param event - The incoming HTTP event.
+ * @param response - The outgoing HTTP response.
+ * @param container - The service container.
+ * @param snapshot - The response snapshot.
+ */
+declare function preparePage(event: IncomingBrowserEvent, response: ReactOutgoingResponse, container: IContainer, snapshot: ResponseSnapshotType): Promise<void>;
+/**
+ * Prepare the error page to render.
+ *
+ * Error pages are prepared sepatately because their handler
+ * is different from the normal page handler.
+ * Their handler takes an error as the first argument and the event as the second.
+ *
+ * @param event - The incoming HTTP event.
+ * @param response - The outgoing HTTP response.
+ * @param container - The service container.
+ * @param snapshot - The response snapshot.
+ */
+declare function prepareErrorPage(event: IncomingBrowserEvent, response: ReactOutgoingResponse, container: IContainer, snapshot: ResponseSnapshotType): Promise<void>;
+/**
+ * Prepare the fallback error page to render.
+ *
+ * We prepare a fallback error page if no event nor error handler is provided.
+ *
+ * @param event - The incoming event.
+ * @param response - The outgoing response.
+ * @param container - The service container.
+ * @param snapshot - The response snapshot.
+ */
+declare function prepareFallbackErrorPage(event: IncomingBrowserEvent, response: ReactOutgoingResponse, container: IContainer, snapshot: ResponseSnapshotType): Promise<void>;
+
+/**
+ * Create an UseReact response.
+ *
+ * @param options - The options for creating the response.
+ * @returns The React response.
+ */
+declare const reactResponse: (options: OutgoingHttpResponseOptions | OutgoingBrowserResponseOptions | RedirectResponseOptions | RedirectBrowserResponseOptions) => Promise<ReactOutgoingResponse>;
+/**
+ * Create an UseReact redirect response.
+ *
+ * @param options - The options for creating the response.
+ * @returns The React redirect response.
+ */
+declare const reactRedirectResponse: (options: RedirectResponseOptions | RedirectBrowserResponseOptions) => Promise<ReactOutgoingResponse>;
+
+/**
+ * UseReactServerErrorHandler options.
+ */
+interface UseReactServerErrorHandlerOptions {
+    logger: ILogger;
+    blueprint: IBlueprint;
+}
+/**
+ * Class representing an UseReactServerErrorHandler.
+ *
+ * Adapter level error handler for React applications.
+ */
+declare class UseReactServerErrorHandler implements IAdapterErrorHandler<unknown, unknown, unknown> {
+    private readonly logger;
+    private readonly blueprint;
+    /**
+     * Create an UseReactServerErrorHandler.
+     *
+     * @param options - UseReactServerErrorHandler options.
+     */
+    constructor({ blueprint }: UseReactServerErrorHandlerOptions);
+    /**
+     * Handle an error.
+     *
+     * @param error - The error to handle.
+     * @param context - The context of the adapter.
+     * @returns The raw response.
+     */
+    handle(error: any, context: AdapterErrorContext<unknown, unknown, unknown>): Promise<AdapterEventBuilderType<unknown>>;
+    /**
+     * Get the error body.
+     *
+     * @param error - The error to handle.
+     * @returns The error body.
+    */
+    private getErrorBody;
+}
+
+/**
+ * Constants for the Stone SNAPSHOT
+ */
+declare const STONE_SNAPSHOT = "__STONE_SNAPSHOT__";
+/**
+ * Constants for the Stone Page Event Outlet
+ */
+declare const STONE_PAGE_EVENT_OUTLET = "stone:inject:react-page:outlet";
+
+/**
+ * Options for configuring the use-react service provider.
+ */
+interface UseReactServiceProviderOptions {
+    container: IContainer;
+}
+/**
+ * Use React Service Provider.
+ */
+declare class UseReactServiceProvider implements IServiceProvider {
+    private readonly container;
+    /**
+     * Constructs a new `UseReactServiceProvider` instance.
+     *
+     * @param container - The container to register services in.
+     */
+    constructor(container: IContainer);
+    /**
+     * Register method for the service provider.
+     */
+    register(): Promiseable<void>;
+    /**
+     * Boot method for the service provider.
+     */
+    boot(): Promiseable<void>;
+    /**
+     * Register the snapshot.
+     *
+     * We save the snapshot on server side rendering and
+     * we use it to hydrate the application on the client side.
+    */
+    private registerSnapshot;
+}
+/**
+ * MetaUseReactServiceProvider
+ */
+declare const MetaUseReactServiceProvider: {
+    module: typeof UseReactServiceProvider;
+    isClass: boolean;
+};
+
+/**
+ * Configuration options for integrating React with Stone.js.
+ */
+interface UseReactConfig {
+    /**
+     * The ID of the root DOM element where React will be mounted.
+     */
+    rootElementId?: string;
+    /**
+     * The content of the HTML template as a string.
+     * This can be used to define the structure of the HTML document.
+     * This is useful for inline templates or when the template is dynamically generated.
+     * Note: This is not a file path, but the actual HTML content.
+     */
+    htmlTemplateContent?: string;
+    /**
+     * A map of layout components with their respective event handlers.
+     */
+    layout?: Record<string, MetaPageLayout>;
+    /**
+     * Handles incoming events for the root React component.
+     */
+    componentEventHandler?: MetaPage<ReactIncomingEvent>;
+    /**
+     * A map of error pages for specific components.
+     */
+    errorPages?: Record<string, MetaErrorPage<ReactIncomingEvent>>;
+    /**
+     * A map of error pages for adapter-level errors.
+     */
+    adapterErrorPages?: Record<string, MetaAdapterErrorPage<unknown, unknown, unknown>>;
+}
+/**
+ * Application-level configuration that extends `AppConfig` with React-specific settings.
+ */
+interface UseReactAppConfig extends Partial<AppConfig<ReactIncomingEvent, ReactOutgoingResponse>> {
+    /**
+     * React integration settings, extending the base application config.
+     */
+    useReact: UseReactConfig;
+}
+/**
+ * Stone.js blueprint for a React-based application.
+ */
+interface UseReactBlueprint extends StoneBlueprint<ReactIncomingEvent, ReactOutgoingResponse> {
+    /**
+     * Contains the full application configuration, including middleware,
+     * lifecycle hooks, and React integration settings.
+     */
+    stone: UseReactAppConfig;
+}
+/**
+ * Default blueprint for a React-based Stone.js application.
+ *
+ * - Defines middleware, lifecycle hooks, and the default HTML template path.
+ */
+declare const useReactBlueprint: UseReactBlueprint;
+
+/**
+ * Utility function to define a factory-based adapter error page.
+ *
+ * @param module - The adapter error page module.
+ * @param options - Optional adapter error page options.
+ * @returns The UseReactBlueprint.
+ */
+declare function defineAdapterErrorPage(module: FactoryAdapterErrorPage<unknown, unknown, unknown>, options?: AdapterErrorPageOptions): UseReactBlueprint;
+/**
+ * Utility function to define a class-based adapter error page.
+ *
+ * @param module - The adapter error page module.
+ * @param options - Adapter error page options.
+ * @returns The UseReactBlueprint.
+ */
+declare function defineAdapterErrorPage(module: AdapterErrorPageClass<unknown, unknown, unknown>, options: AdapterErrorPageOptions & {
+    isClass: boolean;
+}): UseReactBlueprint;
+
+/**
+ * Defines a Stone React app using a factory-based main handler.
+ *
+ * @param module - A factory function for the main page.
+ * @param options - Optional application-level configuration.
+ * @param blueprints - Additional blueprints to merge.
+ * @returns A fully merged Stone blueprint.
+ */
+declare function defineStoneReactApp<U extends ReactIncomingEvent = ReactIncomingEvent>(module: FactoryPage<U>, options?: Partial<UseReactAppConfig>, blueprints?: Array<StoneBlueprint<any, any> & Record<string, any>>): StoneBlueprint<U>;
+/**
+ * Defines a Stone React app using a class-based main handler.
+ *
+ * @param module - A class constructor for the main page.
+ * @param options - Optional application-level configuration.
+ * @param blueprints - Additional blueprints to merge.
+ * @returns A fully merged Stone blueprint.
+ */
+declare function defineStoneReactApp<U extends ReactIncomingEvent = ReactIncomingEvent>(module: PageClass<U>, options: Partial<UseReactAppConfig> & {
+    isClass: boolean;
+}, blueprints?: Array<StoneBlueprint<any, any> & Record<string, any>>): StoneBlueprint<U>;
+/**
+ * Defines a Stone React app without a main handler (router-only).
+ *
+ * @param options - Application-level configuration.
+ * @param blueprints - Additional blueprints to merge.
+ * @returns A fully merged Stone blueprint.
+ */
+declare function defineStoneReactApp<U extends ReactIncomingEvent = ReactIncomingEvent>(options?: Partial<UseReactAppConfig>, blueprints?: Array<StoneBlueprint<any, any> & Record<string, any>>): StoneBlueprint<U>;
+
+/**
+ * Stone Client options.
+ */
+interface StoneClientOptions {
+    children: ReactNode;
+}
+/**
+ * Stone Client.
+ * This component is used to wrap content
+ * that should only be rendered on the client.
+ *
+ * @param options - The options to create the Stone Client.
+ */
+declare const StoneClient: FunctionComponent<StoneClientOptions>;
+
+/**
+ * Utility function to define a factory-based page.
+ *
+ * @param module - The EventHandler module.
+ * @param options - Page definition options.
+ * @returns The UseReactBlueprint.
+ */
+declare function definePage<U extends ReactIncomingEvent = ReactIncomingEvent>(module: FactoryPage<U>, options: PageOptions & {
+    isClass?: undefined;
+}): Partial<StoneBlueprint<U>>;
+/**
+ * Utility function to define a class-based page.
+ *
+ * @param module - The EventHandler module.
+ * @param options - Page definition options.
+ * @returns The UseReactBlueprint.
+ */
+declare function definePage<U extends ReactIncomingEvent = ReactIncomingEvent>(module: PageClass<U>, options: PageOptions & {
+    isClass: true;
+}): Partial<StoneBlueprint<U>>;
+/**
+ * Utility function to define a factory-based page layout.
+ *
+ * @param module - The layout module.
+ * @param options - Optional page layout definition options.
+ * @returns The UseReactBlueprint.
+ */
+declare function definePageLayout(module: FactoryPageLayout, options?: PageLayoutOptions & {
+    isClass?: undefined;
+}): UseReactBlueprint;
+/**
+ * Utility function to define a class-based page layout.
+ *
+ * @param module - The layout module.
+ * @param options - Optional page layout definition options.
+ * @returns The UseReactBlueprint.
+ */
+declare function definePageLayout(module: PageLayoutClass, options: PageLayoutOptions & {
+    isClass: true;
+}): UseReactBlueprint;
+/**
+ * Utility function to define a factory-based error page.
+ *
+ * @param module - The layout module.
+ * @param options - Optional page layout definition options.
+ * @returns The UseReactBlueprint.
+ */
+declare function defineErrorPage(module: FactoryErrorPage<ReactIncomingEvent>, options?: ErrorPageOptions & {
+    isClass?: undefined;
+}): UseReactBlueprint;
+/**
+ * Utility function to define a class-based error page.
+ *
+ * @param module - The layout module.
+ * @param options - Optional page layout definition options.
+ * @returns The UseReactBlueprint.
+ */
+declare function defineErrorPage(module: ErrorPageClass<ReactIncomingEvent>, options: ErrorPageOptions & {
+    isClass: true;
+}): UseReactBlueprint;
+
+/**
+ * Stone Error.
+ */
+declare const StoneError: FunctionComponent;
+
+interface BaseProps {
+    rel?: string;
+    href?: string;
+    target?: string;
+    noRel?: boolean;
+    external?: boolean;
+    className?: string;
+    children: ReactNode;
+    defaultNav?: boolean;
+    selectedClass?: string;
+    ariaCurrentValue?: 'time' | 'location' | 'page' | 'step' | 'date' | 'true' | 'false';
+}
+type StoneLinkOptions = (BaseProps & {
+    href: string;
+    to?: string | NavigateOptions;
+}) | (BaseProps & {
+    href?: string;
+    to: string | NavigateOptions;
+});
+/**
+ * Main StoneLink component delegating to internal or external versions.
+ */
+declare const StoneLink: FunctionComponent<StoneLinkOptions>;
+
+/**
+ * Stone Outlet options.
+ */
+interface StoneOutletOptions {
+    children: ReactNode;
+}
+/**
+ * A dynamic rendering component that updates its content based on a global event.
+ *
+ * - Listens for `stone:inject:react-page:outlet` and updates its view when triggered.
+ * - Uses `useState` to manage the currently displayed content.
+ * - Automatically cleans up event listeners on unmount.
+ *
+ * This component enables dynamic content updates within a Stone.js application.
+ *
+ * @param options - The options to create the Stone Outlet.
+ * @returns The Stone Outlet component.
+ */
+declare const StoneOutlet: FunctionComponent<StoneOutletOptions>;
+
+/**
+ * Stone Page options.
+ */
+interface StonePageOptions {
+    children: ReactNode;
+    context: StoneContextType;
+}
+/**
+ * Provides a scoped `StoneContext` for its children within a strict mode.
+ *
+ * - Wraps content in `React.StrictMode` for enhanced debugging.
+ * - Supplies a `StoneContext.Provider` to get access to the event, data and container.
+ *
+ * This component ensures that all child components have access to the provided
+ * context within a Stone.js application.
+ *
+ * @param options - The options to create the Stone Page.
+ * @returns The Stone Page component.
+ */
+declare const StonePage: FunctionComponent<StonePageOptions>;
+
+/**
+ * Stone Server options.
+ */
+interface StoneServerOptions {
+    children: ReactNode;
+}
+/**
+ * Stone Server.
+ * This component is used to wrap content
+ * that should only be rendered on the server.
+ *
+ * @param options - The options to create the Stone Server.
+ */
+declare const StoneServer: FunctionComponent<StoneServerOptions>;
+
+/**
+ * A class decorator for defining a class as a React Handler layout.
+ *
+ * @param options - Configuration options for the layout definition.
+ * @returns A method decorator to be applied to a class method.
+ *
+ * @example
+ * ```typescript
+ * import { AdapterErrorPage } from '@stone-js/use-react';
+ *
+ * @AdapterErrorPage({ error: 'UserNotFoundError' })
+ * class UserAdapterErrorPage {
+ *   render({ error }) {
+ *     return <h1>User name: {error.message}</h1>;
+ *   }
+ * }
+ * ```
+ */
+declare const AdapterErrorPage: <T extends ClassType = ClassType>(options: AdapterErrorPageOptions) => ClassDecorator;
+
+/**
+ * Hook decorator to mark a method as a lifecycle hook
+ * And automatically add it to the global lifecycle hook registry.
+ *
+ * @example
+ * ```typescript
+ * class MyClass {
+ *    // ...
+ *    @Hook('onPreparingPage')
+ *    onPreparingPage () {}
+ * }
+ * ```
+ *
+ * @param name - The name of the lifecycle hook.
+ * @returns A class decorator function that sets the metadata using the provided options.
+ */
+declare const Hook: <T extends Function = Function>(name: HookName) => MethodDecorator;
+
+/**
+ * A class decorator for defining a class as a React Page route action.
+ * Uses the `Match` decorator internally to register the route with the HTTP `GET` method.
+ *
+ * @param options - Configuration options for the route definition, excluding the `methods` property.
+ * @returns A method decorator to be applied to a class method.
+ *
+ * @example
+ * ```typescript
+ * import { Page } from '@stone-js/use-react';
+ *
+ * @Page('/user-profile')
+ * class UserPage {
+ *   handle({ event }): Record<string, string> {
+ *     return { name: 'Jane Doe' };
+ *   }
+ *
+ *   render({ data }) {
+ *     return <h1>User name: {data.name}</h1>;
+ *   }
+ * }
+ * ```
+ */
+declare const Page: <T extends ClassType = ClassType>(path: string, options?: PageOptions) => ClassDecorator;
+
+/**
+ * A class decorator for defining a class as a React Handler layout.
+ *
+ * @param options - Configuration options for the layout definition.
+ * @returns A method decorator to be applied to a class method.
+ *
+ * @example
+ * ```typescript
+ * import { ErrorPage } from '@stone-js/use-react';
+ *
+ * @ErrorPage({ error: 'UserNotFoundError' })
+ * class UserErrorPage {
+ *   render({ error }) {
+ *     return <h1>User name: {error.message}</h1>;
+ *   }
+ * }
+ * ```
+ */
+declare const ErrorPage: <T extends ClassType = ClassType>(options: ErrorPageOptions) => ClassDecorator;
+
+/**
+ * A class decorator for defining a class as a React Page layout.
+ *
+ * @param options - Configuration options for the layout definition.
+ * @returns A method decorator to be applied to a class method.
+ *
+ * @example
+ * ```typescript
+ * import { PageLayout } from '@stone-js/use-react';
+ *
+ * @PageLayout({ name: 'UserPageLayout' })
+ * class UserPageLayout {
+ *   render({ data }) {
+ *     return <h1>User name: {data.name}</h1>;
+ *   }
+ * }
+ * ```
+ */
+declare const PageLayout: <T extends ClassType = ClassType>(options: PageLayoutOptions) => ClassDecorator;
+
+/**
+ * Decorator to set the status code of the response.
+ *
+ * @param statusCode - The status code of the response.
+ * @param headers - The headers for the response.
+ * @returns A method decorator.
+ *
+ * @example
+ * ```typescript
+ * import { Page, PageStatus } from '@stone-js/use-react';
+ *
+ * @Page('/user-profile')
+ * class UserPage {
+ *   @PageStatus()
+ *   handle() {
+ *     return { name: 'John Doe' };
+ *   }
+ * }
+ * ```
+ */
+declare const PageStatus: <T extends Function = Function>(statusCode?: number, headers?: HeadersType) => MethodDecorator;
+
+/**
+ * Decorator to create a snapshot of the current data.
+ *
+ * @param name - The name of the snapshot.
+ * @returns A method decorator.
+ *
+ * @example
+ * ```typescript
+ * import { Service } from '@stone-js/core';
+ * import { Snapshot } from '@stone-js/use-react';
+ *
+ * @Service({ alias: 'userService' })
+ * class UserService {
+ *   @Snapshot()
+ *   showProfile() {
+ *     return { name: 'John Doe' };
+ *   }
+ * }
+ * ```
+ */
+declare const Snapshot: <T extends Function = Function>(name?: string) => MethodDecorator;
+
+/**
+ * UseReact decorator options.
+ */
+interface UseReactOptions extends Partial<UseReactConfig> {
+}
+/**
+ * UseReact decorator.
+ *
+ * UseReact is a class decorator that allows you to use React components in your Stone application.
+ * The decorator is used to define the React configuration for the class.
+ *
+ * @param options - UseReactOptions
+ * @returns ClassDecorator
+ */
+declare const UseReact: <T extends ClassType = ClassType>(options?: UseReactOptions) => ClassDecorator;
+
+/**
+ * Custom error for react operations.
+ */
+declare class UseReactError extends InitializationError {
+    constructor(message: string, options?: ErrorOptions);
+}
+
+/**
+ * Blueprint middleware to dynamically set lifecycle hooks for react.
+ *
+ * @param context - The configuration context containing modules and blueprint.
+ * @param next - The next pipeline function to continue processing.
+ * @returns The updated blueprint or a promise resolving to it.
+ *
+ * @example
+ * ```typescript
+ * SetUseReactHooksMiddleware(context, next)
+ * ```
+ */
+declare const SetUseReactHooksMiddleware: (context: BlueprintContext<IBlueprint, ClassType>, next: NextMiddleware<BlueprintContext<IBlueprint, ClassType>, IBlueprint>) => Promiseable<IBlueprint>;
+/**
+ * Blueprint middleware to set BrowserResponseMiddleware for the Browser adapter.
+ *
+ * The MetaBrowserResponseMiddleware is an adapter middleware and is useful
+ * for handling outgoing responses and rendering them in the browser.
+ *
+ * @param context - The configuration context containing modules and blueprint.
+ * @param next - The next pipeline function to continue processing.
+ * @returns The updated blueprint or a promise resolving to it.
+ *
+ * @example
+ * ```typescript
+ * SetBrowserResponseMiddlewareMiddleware(context, next)
+ * ```
+ */
+declare const SetBrowserResponseMiddlewareMiddleware: (context: BlueprintContext<IBlueprint, ClassType>, next: NextMiddleware<BlueprintContext<IBlueprint, ClassType>, IBlueprint>) => Promise<IBlueprint>;
+/**
+ * Blueprint middleware to process and register kernel error page definitions from modules.
+ *
+ * @param context - The configuration context containing modules and blueprint.
+ * @param next - The next pipeline function to continue processing.
+ * @returns The updated blueprint or a promise resolving to it.
+ *
+ * @example
+ * ```typescript
+ * SetReactKernelErrorPageMiddleware(context, next)
+ * ```
+ */
+declare const SetReactKernelErrorPageMiddleware: (context: BlueprintContext<IBlueprint, ClassType>, next: NextMiddleware<BlueprintContext<IBlueprint, ClassType>, IBlueprint>) => Promiseable<IBlueprint>;
+/**
+ * Blueprint middleware to process and register adapter error page definitions from modules.
+ *
+ * @param context - The configuration context containing modules and blueprint.
+ * @param next - The next pipeline function to continue processing.
+ * @returns The updated blueprint or a promise resolving to it.
+ *
+ * @example
+ * ```typescript
+ * SetReactAdapterErrorPageMiddleware(context, next)
+ * ```
+ */
+declare const SetReactAdapterErrorPageMiddleware: (context: BlueprintContext<IBlueprint, ClassType>, next: NextMiddleware<BlueprintContext<IBlueprint, ClassType>, IBlueprint>) => Promiseable<IBlueprint>;
+/**
+ * Blueprint middleware to set StaticFileMiddleware for SSR adapter.
+ *
+ * @param context - The configuration context containing modules and blueprint.
+ * @param next - The next pipeline function to continue processing.
+ * @returns The updated blueprint or a promise resolving to it.
+ *
+ * @example
+ * ```typescript
+ * SetSSRStaticFileMiddleware(context, next)
+ * ```
+ */
+declare const SetSSRStaticFileMiddleware: (context: BlueprintContext<IBlueprint, ClassType>, next: NextMiddleware<BlueprintContext<IBlueprint, ClassType>, IBlueprint>) => Promise<IBlueprint>;
+/**
+ * Blueprint middleware to set CompressionMiddleware for SSR adapter.
+ *
+ * @param context - The configuration context containing modules and blueprint.
+ * @param next - The next pipeline function to continue processing.
+ * @returns The updated blueprint or a promise resolving to it.
+ *
+ * @example
+ * ```typescript
+ * SetSSRCompressionMiddleware(context, next)
+ * ```
+ */
+declare const SetSSRCompressionMiddleware: (context: BlueprintContext<IBlueprint, ClassType>, next: NextMiddleware<BlueprintContext<IBlueprint, ClassType>, IBlueprint>) => Promise<IBlueprint>;
+/**
+ * Blueprint middleware to process and register route definitions from modules.
+ *
+ * @param context - The configuration context containing modules and blueprint.
+ * @param next - The next pipeline function to continue processing.
+ * @returns The updated blueprint or a promise resolving to it.
+ *
+ * @example
+ * ```typescript
+ * SetReactRouteDefinitionsMiddleware(context, next)
+ * ```
+ */
+declare const SetReactRouteDefinitionsMiddleware: (context: BlueprintContext<IBlueprint, ClassType>, next: NextMiddleware<BlueprintContext<IBlueprint, ClassType>, IBlueprint>) => Promiseable<IBlueprint>;
+/**
+ * Blueprint middleware to process and register layout definitions from modules.
+ *
+ * @param context - The configuration context containing modules and blueprint.
+ * @param next - The next pipeline function to continue processing.
+ * @returns The updated blueprint or a promise resolving to it.
+ *
+ * @example
+ * ```typescript
+ * SetReactPageLayoutMiddleware(context, next)
+ * ```
+ */
+declare const SetReactPageLayoutMiddleware: (context: BlueprintContext<IBlueprint, ClassType>, next: NextMiddleware<BlueprintContext<IBlueprint, ClassType>, IBlueprint>) => Promiseable<IBlueprint>;
+/**
+ * Blueprint middleware to set the UseReact as the main event handler for the application.
+ *
+ * Set as fallback event handler if none of the other event handlers are registered.
+ *
+ * @param context - The configuration context containing modules and blueprint.
+ * @param next - The next function in the pipeline.
+ * @returns The updated blueprint.
+ *
+ * @example
+ * ```typescript
+ * SetUseReactEventHandlerMiddleware({ modules, blueprint }, next);
+ * ```
+ */
+declare function SetUseReactEventHandlerMiddleware(context: BlueprintContext<IBlueprint, ClassType>, next: NextMiddleware<BlueprintContext<IBlueprint, ClassType>, IBlueprint>): Promise<IBlueprint>;
+/**
+ * Configuration for react processing middleware.
+ *
+ * This array defines a list of middleware pipes, each with a `pipe` function and a `priority`.
+ * These pipes are executed in the order of their priority values, with lower values running first.
+ */
+declare const metaUseReactBlueprintMiddleware: Array<MetaMiddleware<BlueprintContext<IBlueprint, ClassType>, IBlueprint>>;
+
+/**
+ * Adapter Middleware for handling outgoing responses and rendering them in the browser.
+ */
+declare class BrowserResponseMiddleware {
+    private readonly isRendered;
+    private readonly blueprint;
+    /**
+     * Create a BrowserResponseMiddleware.
+     *
+     * @param {blueprint} options - Options for creating the BrowserResponseMiddleware.
+     */
+    constructor({ blueprint }: {
+        blueprint: IBlueprint;
+    });
+    /**
+     * Handles the outgoing response, processes it, and invokes the next middleware in the pipeline.
+     *
+     * @param context - The adapter context containing the raw event, execution context, and other data.
+     * @param next - The next middleware to be invoked in the pipeline.
+     * @returns A promise resolving to the processed context.
+     * @throws {NodeHttpAdapterError} If required components are missing in the context.
+     */
+    handle(context: ReactBrowserAdapterContext, next: NextMiddleware<ReactBrowserAdapterContext, BrowserAdapterResponseBuilder>): Promise<BrowserAdapterResponseBuilder>;
+    /**
+     * Ensures the context and response builder have the required components.
+     */
+    private ensureValidContext;
+    /**
+     * Renders the provided React content.
+     *
+     * @param response - The response object.
+     */
+    private renderComponent;
+    /**
+     * Handles navigation redirection.
+     *
+     * @param path - The path to redirect to.
+     */
+    private handleRedirect;
+    /**
+     * Hydrates the React app when SSR is enabled.
+     *
+     * @param app - The React app to hydrate.
+     */
+    private hydrateReactApp;
+    /**
+     * Renders the React app.
+     *
+     * @param app - The React app to render.
+     */
+    private renderReactApp;
+    /**
+     * Dispatches a component to the layout outlet when no layout is defined.
+     *
+     * @param component - The component to dispatch.
+     */
+    private dispatchComponentToOutlet;
+}
+/**
+ * Meta Middleware for processing browser responses.
+ */
+declare const MetaBrowserResponseMiddleware: {
+    module: typeof BrowserResponseMiddleware;
+    isClass: boolean;
+};
+
+/**
+ * Constants are defined here to prevent Circular dependency between modules
+ * This pattern must be applied to all Stone libraries or third party libraries.
+ */
+/**
+ * A unique symbol key to mark classes as React Page component.
+ */
+declare const REACT_PAGE_KEY: unique symbol;
+/**
+ * A unique symbol key to mark classes as React Page layout component.
+ */
+declare const REACT_PAGE_LAYOUT_KEY: unique symbol;
+/**
+ * A unique symbol key to mark classes as React Error handler component.
+ */
+declare const REACT_ERROR_PAGE_KEY: unique symbol;
+/**
+ * A unique symbol key to mark classes as React Adapter Error handler component.
+ */
+declare const REACT_ADAPTER_ERROR_PAGE_KEY: unique symbol;
+/**
+ * A unique symbol key to mark classes as React Stone application entry point.
+ */
+declare const STONE_REACT_APP_KEY: unique symbol;
+
+export { AdapterErrorPage, BrowserResponseMiddleware, ErrorPage, Hook, MetaBrowserResponseMiddleware, MetaReactRuntime, MetaUseReactServiceProvider, Page, PageLayout, PageStatus, REACT_ADAPTER_ERROR_PAGE_KEY, REACT_ERROR_PAGE_KEY, REACT_PAGE_KEY, REACT_PAGE_LAYOUT_KEY, ReactRuntime, STONE_DOM_ATTR, STONE_PAGE_EVENT_OUTLET, STONE_REACT_APP_KEY, STONE_SNAPSHOT, SetBrowserResponseMiddlewareMiddleware, SetReactAdapterErrorPageMiddleware, SetReactKernelErrorPageMiddleware, SetReactPageLayoutMiddleware, SetReactRouteDefinitionsMiddleware, SetSSRCompressionMiddleware, SetSSRStaticFileMiddleware, SetUseReactEventHandlerMiddleware, SetUseReactHooksMiddleware, Snapshot, StoneClient, StoneContext, StoneError, StoneLink, StoneOutlet, StonePage, StoneServer, UseReact, UseReactBrowserErrorHandler, UseReactError, UseReactEventHandler, UseReactKernelErrorHandler, UseReactServerErrorHandler, UseReactServiceProvider, applyHeadContextToDom, applyHeadContextToHtmlString, applyMeta, buildAdapterErrorComponent, buildAppComponent, buildLayoutComponent, buildPageComponent, defineAdapterErrorPage, defineErrorPage, definePage, definePageLayout, defineStoneReactApp, executeHandler, executeHooks, getAppRootElement, getBrowserContent, getResponseSnapshot, getServerContent, htmlTemplate, hydrateReactApp, isClient, isSSR, isServer, metaUseReactBlueprintMiddleware, onPreparingResponse, prepareErrorPage, prepareFallbackErrorPage, preparePage, reactRedirectResponse, reactResponse, renderReactApp, renderStoneSnapshot, resolveComponent, resolveLazyComponent, snapshotResponse, useReactBlueprint };
+export type { AdapterErrorPageClass, AdapterErrorPageOptions, AdapterErrorPageRenderContext, AdapterErrorPageType, AdapterPageLayoutRenderContext, BrowserResponseContent, ErrorPageClass, ErrorPageHeadContext, ErrorPageOptions, ErrorPageRenderContext, ErrorPageType, FactoryAdapterErrorPage, FactoryErrorPage, FactoryPage, FactoryPageLayout, HeadContext, HeadersType, HookName, IAdapterErrorPage, IErrorPage, IPage, IPageLayout, IRoute, IRouter, ISnapshot, MetaAdapterErrorPage, MetaErrorPage, MetaPage, MetaPageLayout, OnPreparingResponseOptions, PageClass, PageHeadContext, PageLayoutClass, PageLayoutOptions, PageLayoutRenderContext, PageLayoutType, PageOptions, PageRenderContext, PageType, ReactBrowserAdapterContext, ReactIncomingEvent, ReactIncomingEventOptions, ReactLifecycleHookType, ReactOutgoingResponse, ReactOutgoingResponseOptions, ReactRuntimeOptions, ResponseSnapshotType, StoneContextType, StoneLinkOptions, StoneOutletOptions, UseReactAppConfig, UseReactBlueprint, UseReactBrowserErrorHandlerOptions, UseReactConfig, UseReactErrorResponseType, UseReactHookListener, UseReactHookListenerContext, UseReactHookName, UseReactHookType, UseReactOptions, UseReactServerErrorHandlerOptions, UseReactServiceProviderOptions };