hono 4.3.11 → 4.4.0

package/dist/types/helper/factory/index.d.ts

@@ -1,3 +1,7 @@
+/**
+ * @module
+ * Factory Helper for Hono.
+ */
 import { Hono } from '../../hono';
 import type { Env, H, HandlerResponse, Input, MiddlewareHandler } from '../../types';
 type InitApp<E extends Env = Env> = (app: Hono<E>) => void;

package/dist/types/helper/html/index.d.ts

@@ -1,3 +1,7 @@
+/**
+ * @module
+ * html Helper for Hono.
+ */
 import { raw } from '../../utils/html';
 import type { HtmlEscapedString } from '../../utils/html';
 export { raw };

package/dist/types/helper/ssg/index.d.ts

@@ -1,2 +1,6 @@
+/**
+ * @module
+ * SSG Helper for Hono.
+ */
 export * from './ssg';
 export { X_HONO_DISABLE_SSG_HEADER_KEY, ssgParams, isSSGContext, disableSSG, onlySSG, } from './middleware';

package/dist/types/helper/ssg/ssg.d.ts

@@ -25,11 +25,14 @@ export declare const defaultExtensionMap: Record<string, string>;
 export type BeforeRequestHook = (req: Request) => Request | false | Promise<Request | false>;
 export type AfterResponseHook = (res: Response) => Response | false | Promise<Response | false>;
 export type AfterGenerateHook = (result: ToSSGResult) => void | Promise<void>;
+export declare const combineBeforeRequestHooks: (hooks: BeforeRequestHook | BeforeRequestHook[]) => BeforeRequestHook;
+export declare const combineAfterResponseHooks: (hooks: AfterResponseHook | AfterResponseHook[]) => AfterResponseHook;
+export declare const combineAfterGenerateHooks: (hooks: AfterGenerateHook | AfterGenerateHook[]) => AfterGenerateHook;
 export interface ToSSGOptions {
     dir?: string;
-    beforeRequestHook?: BeforeRequestHook;
-    afterResponseHook?: AfterResponseHook;
-    afterGenerateHook?: AfterGenerateHook;
+    beforeRequestHook?: BeforeRequestHook | BeforeRequestHook[];
+    afterResponseHook?: AfterResponseHook | AfterResponseHook[];
+    afterGenerateHook?: AfterGenerateHook | AfterGenerateHook[];
     concurrency?: number;
     extensionMap?: Record<string, string>;
 }

package/dist/types/helper/streaming/index.d.ts

@@ -1,3 +1,7 @@
+/**
+ * @module
+ * Streaming Helper for Hono.
+ */
 export { stream } from './stream';
 export type { SSEMessage } from './sse';
 export { streamSSE, SSEStreamingApi } from './sse';

package/dist/types/helper/testing/index.d.ts

@@ -1,3 +1,7 @@
+/**
+ * @module
+ * Testing Helper for Hono.
+ */
 import type { Client } from '../../client/types';
 import type { ExecutionContext } from '../../context';
 import type { Hono } from '../../hono';

package/dist/types/helper/websocket/index.d.ts

@@ -1,3 +1,7 @@
+/**
+ * @module
+ * WebSocket Helper for Hono.
+ */
 import type { Context } from '../../context';
 import type { MiddlewareHandler } from '../../types';
 /**

package/dist/types/hono-base.d.ts

@@ -1,7 +1,11 @@
+/**
+ * @module
+ * This module is the base module for the Hono object.
+ */
 import { Context } from './context';
 import type { ExecutionContext } from './context';
 import type { Router } from './router';
-import type { Env, ErrorHandler, H, HandlerInterface, MiddlewareHandlerInterface, NotFoundHandler, OnHandlerInterface, MergePath, MergeSchemaPath, Schema, RouterRoute } from './types';
+import type { Env, ErrorHandler, H, HandlerInterface, MergePath, MergeSchemaPath, MiddlewareHandlerInterface, NotFoundHandler, OnHandlerInterface, RouterRoute, Schema } from './types';
 export declare const COMPOSED_HANDLER: unique symbol;
 type GetPath<E extends Env> = (request: Request, options?: {
     env?: E['Bindings'];
@@ -41,21 +45,17 @@ export type HonoOptions<E extends Env> = {
      */
     getPath?: GetPath<E>;
 };
-declare const Hono_base: new <E_1 extends Env = Env, S_1 extends Schema = {}, BasePath_1 extends string = "/">() => {
-    all: HandlerInterface<E_1, "all", S_1, BasePath_1>;
-    options: HandlerInterface<E_1, "options", S_1, BasePath_1>;
-    get: HandlerInterface<E_1, "get", S_1, BasePath_1>;
-    post: HandlerInterface<E_1, "post", S_1, BasePath_1>;
-    put: HandlerInterface<E_1, "put", S_1, BasePath_1>;
-    delete: HandlerInterface<E_1, "delete", S_1, BasePath_1>;
-    patch: HandlerInterface<E_1, "patch", S_1, BasePath_1>;
-} & {
-    on: OnHandlerInterface<E_1, S_1, BasePath_1>;
-} & {
-    use: MiddlewareHandlerInterface<E_1, S_1, BasePath_1>;
-};
-declare class Hono<E extends Env = Env, S extends Schema = {}, BasePath extends string = '/'> extends Hono_base<E, S, BasePath> {
+declare class Hono<E extends Env = Env, S extends Schema = {}, BasePath extends string = '/'> {
     #private;
+    get: HandlerInterface<E, 'get', S, BasePath>;
+    post: HandlerInterface<E, 'post', S, BasePath>;
+    put: HandlerInterface<E, 'put', S, BasePath>;
+    delete: HandlerInterface<E, 'delete', S, BasePath>;
+    options: HandlerInterface<E, 'options', S, BasePath>;
+    patch: HandlerInterface<E, 'patch', S, BasePath>;
+    all: HandlerInterface<E, 'all', S, BasePath>;
+    on: OnHandlerInterface<E, S, BasePath>;
+    use: MiddlewareHandlerInterface<E, S, BasePath>;
     router: Router<[H, RouterRoute]>;
     readonly getPath: GetPath<E>;
     private _basePath;

package/dist/types/http-exception.d.ts

@@ -1,3 +1,7 @@
+/**
+ * @module
+ * This module provides the `HTTPException` class.
+ */
 import type { StatusCode } from './utils/http-status';
 type HTTPExceptionOptions = {
     res?: Response;

package/dist/types/index.d.ts

@@ -1,3 +1,18 @@
+/**
+ * @module
+ *
+ * Hono - Web Framework built on Web Standards
+ *
+ * @example
+ * ```ts
+ * import { Hono } from 'hono'
+ * const app = new Hono()
+ *
+ * app.get('/', (c) => c.text('Hono!'))
+ *
+ * export default app
+ * ```
+ */
 import { Hono } from './hono';
 export type { Env, ErrorHandler, Handler, MiddlewareHandler, Next, NotFoundHandler, ValidationTargets, Input, Schema, ToSchema, TypedResponse, } from './types';
 export type { Context, ContextVariableMap, ContextRenderer, ExecutionContext } from './context';

package/dist/types/jsx/base.d.ts

@@ -1,6 +1,6 @@
-import type { StringBuffer, HtmlEscaped, HtmlEscapedString } from '../utils/html';
+import type { HtmlEscaped, HtmlEscapedString, StringBuffer } from '../utils/html';
 import type { Context } from './context';
-import type { IntrinsicElements as IntrinsicElementsDefined } from './intrinsic-elements';
+import type { Hono, IntrinsicElements as IntrinsicElementsDefined } from './intrinsic-elements';
 export type Props = Record<string, any>;
 export type FC<P = Props> = {
     (props: P): HtmlEscapedString | Promise<HtmlEscapedString>;
@@ -8,15 +8,13 @@ export type FC<P = Props> = {
     displayName?: string | undefined;
 };
 export type DOMAttributes = Hono.HTMLAttributes;
-declare global {
-    namespace JSX {
-        type Element = HtmlEscapedString | Promise<HtmlEscapedString>;
-        interface ElementChildrenAttribute {
-            children: Child;
-        }
-        interface IntrinsicElements extends IntrinsicElementsDefined {
-            [tagName: string]: Props;
-        }
+export declare namespace JSX {
+    type Element = HtmlEscapedString | Promise<HtmlEscapedString>;
+    interface ElementChildrenAttribute {
+        children: Child;
+    }
+    interface IntrinsicElements extends IntrinsicElementsDefined {
+        [tagName: string]: Props;
     }
 }
 type LocalContexts = [Context<unknown>, unknown][];
@@ -46,4 +44,5 @@ export declare const Fragment: ({ children, }: {
 }) => HtmlEscapedString;
 export declare const isValidElement: (element: unknown) => element is JSXNode;
 export declare const cloneElement: <T extends JSXNode | JSX.Element>(element: T, props: Partial<Props>, ...children: Child[]) => T;
+export declare const reactAPICompatVersion = "18.0.0-hono-jsx";
 export {};

package/dist/types/jsx/components.d.ts

@@ -1,5 +1,5 @@
 import type { HtmlEscapedString } from '../utils/html';
-import type { FC, PropsWithChildren, Child } from '.';
+import type { Child, FC, PropsWithChildren } from './';
 export declare const childrenToString: (children: Child[]) => Promise<HtmlEscapedString[]>;
 export type ErrorHandler = (error: Error) => void;
 export type FallbackRender = (error: Error) => Child;

package/dist/types/jsx/context.d.ts

@@ -1,4 +1,4 @@
-import type { FC, PropsWithChildren } from '.';
+import type { FC, PropsWithChildren } from './';
 export interface Context<T> {
     values: T[];
     Provider: FC<PropsWithChildren<{

package/dist/types/jsx/dom/client.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @module
+ * This module provides APIs for `hono/jsx/dom/client`, which is compatible with `react-dom/client`.
+ */
+import type { Child } from '../base';
+export interface Root {
+    render(children: Child): void;
+    unmount(): void;
+}
+export type RootOptions = Record<string, unknown>;
+/**
+ * Create a root object for rendering
+ * @param element Render target
+ * @param options Options for createRoot (not supported yet)
+ * @returns Root object has `render` and `unmount` methods
+ */
+export declare const createRoot: (element: HTMLElement | DocumentFragment, options?: RootOptions) => Root;
+/**
+ * Create a root object and hydrate app to the target element.
+ * In hono/jsx/dom, hydrate is equivalent to render.
+ * @param element Render target
+ * @param reactNode A JSXNode to render
+ * @param options Options for createRoot (not supported yet)
+ * @returns Root object has `render` and `unmount` methods
+ */
+export declare const hydrateRoot: (element: HTMLElement | DocumentFragment, reactNode: Child, options?: RootOptions) => Root;

package/dist/types/jsx/dom/components.d.ts

@@ -1,5 +1,5 @@
-import type { FC, PropsWithChildren, Child } from '..';
-import type { FallbackRender, ErrorHandler } from '../components';
+import type { Child, FC, PropsWithChildren } from '../';
+import type { ErrorHandler, FallbackRender } from '../components';
 export declare const ErrorBoundary: FC<PropsWithChildren<{
     fallback?: Child;
     fallbackRender?: FallbackRender;

package/dist/types/jsx/dom/css.d.ts

@@ -1,4 +1,8 @@
-import type { FC, PropsWithChildren } from '..';
+/**
+ * @module
+ * This module provides APIs that enable `hono/jsx/dom` to support.
+ */
+import type { FC, PropsWithChildren } from '../';
 import type { CssClassName, CssVariableType } from '../../helper/css/common';
 export { rawCssString } from '../../helper/css/common';
 interface CreateCssJsxDomObjectsType {
@@ -12,6 +16,27 @@ interface CreateCssJsxDomObjectsType {
     ];
 }
 export declare const createCssJsxDomObjects: CreateCssJsxDomObjectsType;
+interface CssType {
+    (strings: TemplateStringsArray, ...values: CssVariableType[]): string;
+}
+interface CxType {
+    (...args: (string | boolean | null | undefined)[]): string;
+}
+interface KeyframesType {
+    (strings: TemplateStringsArray, ...values: CssVariableType[]): CssClassName;
+}
+interface ViewTransitionType {
+    (strings: TemplateStringsArray, ...values: CssVariableType[]): string;
+    (content: string): string;
+    (): string;
+}
+interface DefaultContextType {
+    css: CssType;
+    cx: CxType;
+    keyframes: KeyframesType;
+    viewTransition: ViewTransitionType;
+    Style: FC<PropsWithChildren<void>>;
+}
 /**
  * @experimental
  * `createCssContext` is an experimental feature.
@@ -19,45 +44,31 @@ export declare const createCssJsxDomObjects: CreateCssJsxDomObjectsType;
  */
 export declare const createCssContext: ({ id }: {
     id: Readonly<string>;
-}) => {
-    css: (strings: TemplateStringsArray, ...values: CssVariableType[]) => string;
-    cx: (...args: (string | boolean | null | undefined)[]) => string;
-    keyframes: (strings: TemplateStringsArray, ...values: CssVariableType[]) => CssClassName;
-    viewTransition: {
-        (strings: TemplateStringsArray, ...values: CssVariableType[]): string;
-        (content: string): string;
-        (): string;
-    };
-    Style: FC<PropsWithChildren<void>>;
-};
+}) => DefaultContextType;
 /**
  * @experimental
  * `css` is an experimental feature.
  * The API might be changed.
  */
-export declare const css: (strings: TemplateStringsArray, ...values: CssVariableType[]) => string;
+export declare const css: CssType;
 /**
  * @experimental
  * `cx` is an experimental feature.
  * The API might be changed.
  */
-export declare const cx: (...args: (string | boolean | null | undefined)[]) => string;
+export declare const cx: CxType;
 /**
  * @experimental
  * `keyframes` is an experimental feature.
  * The API might be changed.
  */
-export declare const keyframes: (strings: TemplateStringsArray, ...values: CssVariableType[]) => CssClassName;
+export declare const keyframes: KeyframesType;
 /**
  * @experimental
  * `viewTransition` is an experimental feature.
  * The API might be changed.
  */
-export declare const viewTransition: {
-    (strings: TemplateStringsArray, ...values: CssVariableType[]): string;
-    (content: string): string;
-    (): string;
-};
+export declare const viewTransition: ViewTransitionType;
 /**
  * @experimental
  * `Style` is an experimental feature.

package/dist/types/jsx/dom/index.d.ts

@@ -1,17 +1,22 @@
-import type { Props, Child, DOMAttributes, JSXNode } from '../base';
-import { memo, isValidElement } from '../base';
+/**
+ * @module
+ * This module provides APIs for `hono/jsx/dom`.
+ */
+import { isValidElement, memo, reactAPICompatVersion } from '../base';
+import type { Child, DOMAttributes, JSX, JSXNode, Props } from '../base';
 import { Children } from '../children';
 import { useContext } from '../context';
-import { useState, useEffect, useRef, useCallback, use, startTransition, useTransition, useDeferredValue, startViewTransition, useViewTransition, useMemo, useLayoutEffect, useReducer, useId, useDebugValue, createRef, forwardRef, useImperativeHandle, useSyncExternalStore } from '../hooks';
-import { Suspense, ErrorBoundary } from './components';
+import { createRef, forwardRef, startTransition, startViewTransition, use, useCallback, useDebugValue, useDeferredValue, useEffect, useId, useImperativeHandle, useInsertionEffect, useLayoutEffect, useMemo, useReducer, useRef, useState, useSyncExternalStore, useTransition, useViewTransition } from '../hooks';
+import { ErrorBoundary, Suspense } from './components';
 import { createContext } from './context';
 import { Fragment } from './jsx-runtime';
-import { flushSync, createPortal } from './render';
+import { createPortal, flushSync } from './render';
 export { render } from './render';
 declare const createElement: (tag: string | ((props: Props) => JSXNode), props: Props | null, ...children: Child[]) => JSXNode;
 declare const cloneElement: <T extends JSXNode | JSX.Element>(element: T, props: Props, ...children: Child[]) => T;
-export { createElement as jsx, useState, useEffect, useRef, useCallback, use, startTransition, useTransition, useDeferredValue, startViewTransition, useViewTransition, useMemo, useLayoutEffect, useReducer, useId, useDebugValue, createRef, forwardRef, useImperativeHandle, useSyncExternalStore, Suspense, ErrorBoundary, createContext, useContext, memo, isValidElement, createElement, cloneElement, Children, Fragment, DOMAttributes, flushSync, createPortal, };
+export { reactAPICompatVersion as version, createElement as jsx, useState, useEffect, useRef, useCallback, use, startTransition, useTransition, useDeferredValue, startViewTransition, useViewTransition, useMemo, useLayoutEffect, useInsertionEffect, useReducer, useId, useDebugValue, createRef, forwardRef, useImperativeHandle, useSyncExternalStore, Suspense, ErrorBoundary, createContext, useContext, memo, isValidElement, createElement, cloneElement, Children, Fragment, DOMAttributes, flushSync, createPortal, };
 declare const _default: {
+    version: string;
     useState: {
         <T>(initialState: T | (() => T)): [T, (newState: T | ((currentState: T) => T)) => void];
         <T_1 = undefined>(): [T_1 | undefined, (newState: T_1 | ((currentState: T_1 | undefined) => T_1 | undefined) | undefined) => void];
@@ -27,6 +32,7 @@ declare const _default: {
     useViewTransition: () => [boolean, (callback: () => void) => void];
     useMemo: <T_6>(factory: () => T_6, deps: readonly unknown[]) => T_6;
     useLayoutEffect: (effect: () => void | (() => void), deps?: readonly unknown[] | undefined) => void;
+    useInsertionEffect: (effect: () => void | (() => void), deps?: readonly unknown[] | undefined) => void;
     useReducer: <T_7, A>(reducer: (state: T_7, action: A) => T_7, initialArg: T_7, init?: ((initialState: T_7) => T_7) | undefined) => [T_7, (action: A) => void];
     useId: () => string;
     useDebugValue: (_value: unknown, _formatter?: ((value: unknown) => string) | undefined) => void;
@@ -63,4 +69,4 @@ declare const _default: {
 };
 export default _default;
 export type { Context } from '../context';
-export * from '../types';
+export type * from '../types';

package/dist/types/jsx/dom/jsx-dev-runtime.d.ts

@@ -1,3 +1,7 @@
-import type { Props, JSXNode } from '../base';
+/**
+ * @module
+ * This module provides the `hono/jsx/dom` dev runtime.
+ */
+import type { JSXNode, Props } from '../base';
 export declare const jsxDEV: (tag: string | Function, props: Props, key?: string) => JSXNode;
 export declare const Fragment: (props: Record<string, unknown>) => JSXNode;

package/dist/types/jsx/dom/jsx-runtime.d.ts

@@ -1,2 +1,6 @@
+/**
+ * @module
+ * This module provides the `hono/jsx/dom` runtime.
+ */
 export { jsxDEV as jsx, Fragment } from './jsx-dev-runtime';
 export { jsxDEV as jsxs } from './jsx-dev-runtime';

package/dist/types/jsx/dom/render.d.ts

@@ -1,5 +1,4 @@
-import type { JSXNode } from '../base';
-import type { FC, Child, Props } from '../base';
+import type { Child, FC, JSXNode, Props } from '../base';
 import { DOM_RENDERER, DOM_STASH } from '../constants';
 import type { Context as JSXContext } from '../context';
 export type HasRenderToDom = FC<any> & {
@@ -49,8 +48,10 @@ export type Context = [
 ] | [PendingType, boolean, UpdateHook, boolean] | [PendingType, boolean, UpdateHook] | [PendingType, boolean] | [PendingType] | [];
 export declare const buildDataStack: [Context, Node][];
 export declare const build: (context: Context, node: NodeObject, topLevelErrorHandlerNode: NodeObject | undefined, children?: Child[]) => void;
+export declare const buildNode: (node: Child) => Node | undefined;
 export declare const update: (context: Context, node: NodeObject) => Promise<NodeObject | undefined>;
-export declare const render: (jsxNode: unknown, container: Container) => void;
+export declare const renderNode: (node: NodeObject, container: Container) => void;
+export declare const render: (jsxNode: Child, container: Container) => void;
 export declare const flushSync: (callback: () => void) => void;
 export declare const createPortal: (children: Child, container: HTMLElement, key?: string) => Child;
 export {};

package/dist/types/jsx/dom/utils.d.ts

@@ -1 +1,7 @@
+import type { JSXNode, Props } from '../base';
 export declare const setInternalTagFlag: (fn: Function) => Function;
+export declare const newJSXNode: (obj: {
+    tag: string | Function;
+    props?: Props;
+    key?: string;
+}) => JSXNode;

package/dist/types/jsx/hooks/index.d.ts

@@ -1,3 +1,4 @@
+import type { JSX } from '../base';
 type UpdateStateFunction<T> = (newState: T | ((currentState: T) => T)) => void;
 export declare const STASH_EFFECT = 1;
 export type EffectData = [
@@ -7,6 +8,8 @@ export type EffectData = [
     // layout effect
     (() => void) | undefined,
     // cleanup
+    (() => void) | undefined,
+    // effect
     (() => void) | undefined
 ];
 export declare const startViewTransition: (callback: () => void) => void;
@@ -22,6 +25,7 @@ export declare const useState: UseStateType;
 export declare const useReducer: <T, A>(reducer: (state: T, action: A) => T, initialArg: T, init?: ((initialState: T) => T) | undefined) => [T, (action: A) => void];
 export declare const useEffect: (effect: () => void | (() => void), deps?: readonly unknown[]) => void;
 export declare const useLayoutEffect: (effect: () => void | (() => void), deps?: readonly unknown[]) => void;
+export declare const useInsertionEffect: (effect: () => void | (() => void), deps?: readonly unknown[]) => void;
 export declare const useCallback: <T extends (...args: unknown[]) => unknown>(callback: T, deps: readonly unknown[]) => T;
 export type RefObject<T> = {
     current: T | null;

package/dist/types/jsx/index.d.ts

@@ -1,12 +1,17 @@
-import { jsx, memo, Fragment, isValidElement, cloneElement } from './base';
+/**
+ * @module
+ * JSX for Hono.
+ */
+import { Fragment, cloneElement, isValidElement, jsx, memo, reactAPICompatVersion } from './base';
 import type { DOMAttributes } from './base';
 import { Children } from './children';
 import { ErrorBoundary } from './components';
 import { createContext, useContext } from './context';
-import { useState, useEffect, useRef, useCallback, use, startTransition, useTransition, useDeferredValue, startViewTransition, useViewTransition, useMemo, useLayoutEffect, useReducer, useId, useDebugValue, createRef, forwardRef, useImperativeHandle, useSyncExternalStore } from './hooks';
+import { createRef, forwardRef, startTransition, startViewTransition, use, useCallback, useDebugValue, useDeferredValue, useEffect, useId, useImperativeHandle, useInsertionEffect, useLayoutEffect, useMemo, useReducer, useRef, useState, useSyncExternalStore, useTransition, useViewTransition } from './hooks';
 import { Suspense } from './streaming';
-export { jsx, memo, Fragment, isValidElement, jsx as createElement, cloneElement, ErrorBoundary, createContext, useContext, useState, useEffect, useRef, useCallback, useReducer, useId, useDebugValue, use, startTransition, useTransition, useDeferredValue, startViewTransition, useViewTransition, useMemo, useLayoutEffect, createRef, forwardRef, useImperativeHandle, useSyncExternalStore, Suspense, Children, DOMAttributes, };
+export { reactAPICompatVersion as version, jsx, memo, Fragment, isValidElement, jsx as createElement, cloneElement, ErrorBoundary, createContext, useContext, useState, useEffect, useRef, useCallback, useReducer, useId, useDebugValue, use, startTransition, useTransition, useDeferredValue, startViewTransition, useViewTransition, useMemo, useLayoutEffect, useInsertionEffect, createRef, forwardRef, useImperativeHandle, useSyncExternalStore, Suspense, Children, DOMAttributes, };
 declare const _default: {
+    version: string;
     memo: <T>(component: import("./base").FC<T>, propsAreEqual?: (prevProps: Readonly<T>, nextProps: Readonly<T>) => boolean) => import("./base").FC<T>;
     Fragment: ({ children, }: {
         key?: string | undefined;
@@ -14,7 +19,7 @@ declare const _default: {
     }) => import("../utils/html").HtmlEscapedString;
     isValidElement: (element: unknown) => element is import("./base").JSXNode;
     createElement: (tag: string | Function, props: import("./base").Props | null, ...children: (string | number | import("../utils/html").HtmlEscapedString)[]) => import("./base").JSXNode;
-    cloneElement: <T_1 extends import("./base").JSXNode | JSX.Element>(element: T_1, props: Partial<import("./base").Props>, ...children: import("./base").Child[]) => T_1;
+    cloneElement: <T_1 extends import("./base").JSXNode | import("./base").JSX.Element>(element: T_1, props: Partial<import("./base").Props>, ...children: import("./base").Child[]) => T_1;
     ErrorBoundary: import("./base").FC<import("./types").PropsWithChildren<{
         fallback?: import("./base").Child;
         fallbackRender?: import("./components").FallbackRender | undefined;
@@ -40,10 +45,11 @@ declare const _default: {
     useViewTransition: () => [boolean, (callback: () => void) => void];
     useMemo: <T_11>(factory: () => T_11, deps: readonly unknown[]) => T_11;
     useLayoutEffect: (effect: () => void | (() => void), deps?: readonly unknown[] | undefined) => void;
+    useInsertionEffect: (effect: () => void | (() => void), deps?: readonly unknown[] | undefined) => void;
     createRef: <T_12>() => import("./hooks").RefObject<T_12>;
-    forwardRef: <T_13, P = {}>(Component: (props: P, ref?: import("./hooks").RefObject<T_13> | undefined) => JSX.Element) => (props: P & {
+    forwardRef: <T_13, P = {}>(Component: (props: P, ref?: import("./hooks").RefObject<T_13> | undefined) => import("./base").JSX.Element) => (props: P & {
         ref?: import("./hooks").RefObject<T_13> | undefined;
-    }) => JSX.Element;
+    }) => import("./base").JSX.Element;
     useImperativeHandle: <T_14>(ref: import("./hooks").RefObject<T_14>, createHandle: () => T_14, deps: readonly unknown[]) => void;
     useSyncExternalStore: <T_15>(subscribe: (callback: (value: T_15) => void) => () => void, getSnapshot: () => T_15, getServerSnapshot?: (() => T_15) | undefined) => T_15;
     Suspense: import("./base").FC<import("./types").PropsWithChildren<{
@@ -58,4 +64,4 @@ declare const _default: {
     };
 };
 export default _default;
-export * from './types';
+export type * from './types';