elysia 1.0.4 → 1.0.6

package/dist/bun/index.d.ts

@@ -1,10 +1,1427 @@
-import 'bun';
-import 'memoirist';
-export { Static, TSchema } from '@sinclair/typebox';
-export { A as AfterHandler, K as BodyHandler, a3 as Checksum, C as ComposedHandler, az as Context, e as Cookie, c as CookieOptions, D as DefinitionBase, E as Elysia, g as ElysiaConfig, W as ErrorHandler, u as HTTPMethod, H as Handler, I as InputSchema, Z as InternalRoute, s as LifeCycleEvent, L as LifeCycleStore, ac as LifeCycleType, _ as ListenCallback, Y as LocalHook, h as MaybePromise, v as MergeSchema, x as OptionalHandler, aA as PreContext, N as PreHandler, m as RouteBase, o as RouteSchema, S as SchemaValidator, k as SingletonBase, B as TraceEvent, T as TraceHandler, F as TraceProcess, a as TraceReporter, b as TraceStream, q as UnwrapRoute, U as UnwrapSchema, V as VoidHandler, E as default, al as getResponseSchemaValidator, ak as getSchemaValidator, aN as mapCompactResponse, aM as mapEarlyResponse, aL as mapResponse, aj as mergeHook, ag as mergeObjectArray, aB as t } from './dynamic-handle-DrPvRYu3.js';
-export { InternalServerError, InvalidCookieSignature, NotFoundError, ParseError, ValidationError, error } from './error.js';
-import '@sinclair/typebox/compiler';
-import 'openapi-types';
-import 'eventemitter3';
-import '@sinclair/typebox/system';
-import 'undici-types';
+/// <reference types="bun-types" />
+/// <reference types="node" />
+/// <reference types="bun-types" />
+/// <reference types="bun-types" />
+import type { Serve, Server } from 'bun';
+import { Memoirist } from 'memoirist';
+import { type Static, type TSchema } from '@sinclair/typebox';
+import type { Context } from './context';
+import { t } from './type-system';
+import type { WS } from './ws/types';
+import { type DynamicHandler } from './dynamic-handle';
+import type { ElysiaConfig, SingletonBase, DefinitionBase, ComposedHandler, InputSchema, LocalHook, MergeSchema, RouteSchema, UnwrapRoute, InternalRoute, HTTPMethod, SchemaValidator, VoidHandler, PreHandler, BodyHandler, OptionalHandler, AfterHandler, ErrorHandler, LifeCycleStore, MaybePromise, Prettify, Prettify2, ListenCallback, AddPrefix, AddSuffix, AddPrefixCapitalize, AddSuffixCapitalize, TraceHandler, MaybeArray, GracefulHandler, GetPathParameter, MapResponse, MacroManager, BaseMacro, MacroToProperty, TransformHandler, MetadataBase, RouteBase, CreateEden, ComposeElysiaResponse, InlineHandler, LifeCycleType, MacroQueue, EphemeralType, ExcludeElysiaResponse } from './types';
+/**
+ * ### Elysia Server
+ * Main instance to create web server using Elysia
+ *
+ * ---
+ * @example
+ * ```typescript
+ * import { Elysia } from 'elysia'
+ *
+ * new Elysia()
+ *     .get("/", () => "Hello")
+ *     .listen(8080)
+ * ```
+ */
+export default class Elysia<const in out BasePath extends string = '', const in out Scoped extends boolean = false, const in out Singleton extends SingletonBase = {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, const in out Definitions extends DefinitionBase = {
+    type: {};
+    error: {};
+}, const in out Metadata extends MetadataBase = {
+    schema: {};
+    macro: {};
+}, const out Routes extends RouteBase = {}, const in out Ephemeral extends EphemeralType = {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, const in out Volatile extends EphemeralType = {
+    derive: {};
+    resolve: {};
+    schema: {};
+}> {
+    config: ElysiaConfig<BasePath, Scoped>;
+    server: Server | null;
+    private dependencies;
+    private reporter;
+    _routes: Routes;
+    _types: {
+        Prefix: BasePath;
+        Scoped: Scoped;
+        Singleton: Singleton;
+        Definitions: Definitions;
+        Metadata: Metadata;
+    };
+    _ephemeral: Ephemeral;
+    _volatile: Volatile;
+    protected singleton: Singleton;
+    get store(): Singleton['store'];
+    get decorator(): Singleton['decorator'];
+    get _scoped(): Scoped;
+    protected definitions: {
+        type: Record<string, TSchema>;
+        error: Record<string, Error>;
+    };
+    protected extender: {
+        macros: MacroQueue;
+    };
+    protected validator: SchemaValidator | null;
+    event: LifeCycleStore;
+    telemetry: {
+        stack: string | undefined;
+    };
+    router: {
+        http: Memoirist<ComposedHandler>;
+        ws: Memoirist<ComposedHandler>;
+        dynamic: Memoirist<DynamicHandler>;
+        static: {
+            http: {
+                handlers: ComposedHandler[];
+                variables: string;
+                map: Record<string, {
+                    code: string;
+                    all?: string | undefined;
+                }>;
+                all: string;
+            };
+            ws: Record<string, number>;
+        };
+        history: InternalRoute[];
+    };
+    protected inference: {
+        readonly event: {
+            readonly body: false;
+            readonly cookie: false;
+            readonly headers: false;
+            readonly queries: [];
+            readonly query: false;
+            readonly set: false;
+            readonly unknownQueries: false;
+        };
+        readonly trace: {
+            readonly request: false;
+            readonly parse: false;
+            readonly transform: false;
+            readonly handle: false;
+            readonly beforeHandle: false;
+            readonly afterHandle: false;
+            readonly error: false;
+            readonly context: false;
+            readonly store: false;
+            readonly set: false;
+        };
+    };
+    private promisedModules;
+    constructor(config?: ElysiaConfig<BasePath, Scoped>);
+    private getServer;
+    get routes(): InternalRoute[];
+    protected routeTree: Map<string, number>;
+    private add;
+    private setHeaders?;
+    headers(header: Context['set']['headers'] | undefined): this;
+    /**
+     * ### start | Life cycle event
+     * Called after server is ready for serving
+     *
+     * ---
+     * @example
+     * ```typescript
+     * new Elysia()
+     *     .onStart(({ url, port }) => {
+     *         console.log("Running at ${url}:${port}")
+     *     })
+     *     .listen(8080)
+     * ```
+     */
+    onStart(handler: MaybeArray<GracefulHandler<this>>): this;
+    /**
+     * ### request | Life cycle event
+     * Called on every new request is accepted
+     *
+     * ---
+     * @example
+     * ```typescript
+     * new Elysia()
+     *     .onRequest(({ method, url }) => {
+     *         saveToAnalytic({ method, url })
+     *     })
+     * ```
+     */
+    onRequest<const Schema extends RouteSchema>(handler: MaybeArray<PreHandler<MergeSchema<Schema, Metadata['schema'] & Ephemeral['schema'] & Volatile['schema']>, Singleton & {
+        derive: Ephemeral['derive'] & Volatile['derive'];
+        resolve: Ephemeral['resolve'] & Volatile['resolve'];
+    }>>): this;
+    /**
+     * ### parse | Life cycle event
+     * Callback function to handle body parsing
+     *
+     * If truthy value is returned, will be assigned to `context.body`
+     * Otherwise will skip the callback and look for the next one.
+     *
+     * Equivalent to Express's body parser
+     *
+     * ---
+     * @example
+     * ```typescript
+     * new Elysia()
+     *     .onParse((request, contentType) => {
+     *         if(contentType === "application/json")
+     *             return request.json()
+     *     })
+     * ```
+     */
+    onParse<const Schema extends RouteSchema>(parser: MaybeArray<BodyHandler<MergeSchema<Schema, Metadata['schema'] & Ephemeral['schema'] & Volatile['schema']>, Singleton & {
+        derive: Ephemeral['derive'] & Volatile['derive'];
+        resolve: Ephemeral['resolve'] & Volatile['resolve'];
+    }, BasePath>>): this;
+    /**
+     * ### parse | Life cycle event
+     * Callback function to handle body parsing
+     *
+     * If truthy value is returned, will be assigned to `context.body`
+     * Otherwise will skip the callback and look for the next one.
+     *
+     * Equivalent to Express's body parser
+     *
+     * ---
+     * @example
+     * ```typescript
+     * new Elysia()
+     *     .onParse((request, contentType) => {
+     *         if(contentType === "application/json")
+     *             return request.json()
+     *     })
+     * ```
+     */
+    onParse<const Schema extends RouteSchema, const Type extends LifeCycleType>(options: {
+        as?: Type;
+    }, parser: MaybeArray<BodyHandler<MergeSchema<Schema, Metadata['schema'] & Ephemeral['schema'] & Volatile['schema']>, Singleton & ('global' extends Type ? {
+        derive: Partial<Ephemeral['derive'] & Volatile['derive']>;
+        resolve: Partial<Ephemeral['resolve'] & Volatile['resolve']>;
+    } : 'scoped' extends Type ? {
+        derive: Ephemeral['derive'] & Partial<Volatile['derive']>;
+        resolve: Ephemeral['resolve'] & Partial<Volatile['resolve']>;
+    } : {
+        derive: Ephemeral['derive'] & Volatile['derive'];
+        resolve: Ephemeral['resolve'] & Volatile['resolve'];
+    })>>): this;
+    /**
+     * ### transform | Life cycle event
+     * Assign or transform anything related to context before validation.
+     *
+     * ---
+     * @example
+     * ```typescript
+     * new Elysia()
+     *     .onTransform(({ params }) => {
+     *         if(params.id)
+     *             params.id = +params.id
+     *     })
+     * ```
+     */
+    onTransform<const Schema extends RouteSchema>(handler: MaybeArray<TransformHandler<MergeSchema<Schema, Metadata['schema'] & Ephemeral['schema'] & Volatile['schema']>, Singleton & {
+        derive: Ephemeral['derive'] & Volatile['derive'];
+        resolve: Ephemeral['resolve'] & Volatile['resolve'];
+    }, BasePath>>): this;
+    /**
+     * ### transform | Life cycle event
+     * Assign or transform anything related to context before validation.
+     *
+     * ---
+     * @example
+     * ```typescript
+     * new Elysia()
+     *     .onTransform(({ params }) => {
+     *         if(params.id)
+     *             params.id = +params.id
+     *     })
+     * ```
+     */
+    onTransform<const Schema extends RouteSchema, const Type extends LifeCycleType>(options: {
+        as?: Type;
+    }, handler: MaybeArray<TransformHandler<MergeSchema<Schema, Metadata['schema'] & Ephemeral['schema'] & Volatile['schema']>, Singleton & ('global' extends Type ? {
+        derive: Ephemeral['derive'] & Volatile['derive'];
+        resolve: Ephemeral['resolve'] & Volatile['resolve'];
+    } : 'scoped' extends Type ? {
+        derive: Ephemeral['derive'] & Partial<Volatile['derive']>;
+        resolve: Ephemeral['resolve'] & Partial<Volatile['resolve']>;
+    } : {
+        derive: Partial<Ephemeral['derive'] & Volatile['derive']>;
+        resolve: Partial<Ephemeral['resolve'] & Volatile['resolve']>;
+    })>>): this;
+    /**
+     * Derive new property for each request with access to `Context`.
+     *
+     * If error is thrown, the scope will skip to handling error instead.
+     *
+     * ---
+     * @example
+     * new Elysia()
+     *     .state('counter', 1)
+     *     .derive(({ store }) => ({
+     *         increase() {
+     *             store.counter++
+     *         }
+     *     }))
+     */
+    resolve<const Resolver extends Record<string, unknown>, const Type extends LifeCycleType>(options: {
+        as?: Type;
+    }, resolver: (context: Prettify<Context<Metadata['schema'] & Ephemeral['schema'] & Volatile['schema'], Singleton & ('global' extends Type ? {
+        derive: Partial<Ephemeral['derive'] & Volatile['derive']>;
+        resolve: Partial<Ephemeral['resolve'] & Volatile['resolve']>;
+    } : 'scoped' extends Type ? {
+        derive: Ephemeral['derive'] & Partial<Volatile['derive']>;
+        resolve: Ephemeral['resolve'] & Partial<Volatile['resolve']>;
+    } : {
+        derive: Ephemeral['derive'] & Volatile['derive'];
+        resolve: Ephemeral['resolve'] & Volatile['resolve'];
+    })>>) => MaybePromise<Resolver>): Type extends 'global' ? Elysia<BasePath, Scoped, {
+        decorator: Singleton['decorator'];
+        store: Singleton['store'];
+        derive: Singleton['resolve'];
+        resolve: Prettify<Singleton['resolve'] & ExcludeElysiaResponse<Resolver>>;
+    }, Definitions, Metadata, Routes, Ephemeral, Volatile> : Type extends 'scoped' ? Elysia<BasePath, Scoped, Singleton, Definitions, Metadata, Routes, {
+        derive: Ephemeral['resolve'];
+        resolve: Prettify<Ephemeral['resolve'] & ExcludeElysiaResponse<Resolver>>;
+        schema: Ephemeral['schema'];
+    }, Volatile> : Elysia<BasePath, Scoped, Singleton, Definitions, Metadata, Routes, Ephemeral, {
+        derive: Volatile['resolve'];
+        resolve: Prettify<Volatile['resolve'] & ExcludeElysiaResponse<Resolver>>;
+        schema: Volatile['schema'];
+    }>;
+    /**
+     * Derive new property for each request with access to `Context`.
+     *
+     * If error is thrown, the scope will skip to handling error instead.
+     *
+     * ---
+     * @example
+     * new Elysia()
+     *     .state('counter', 1)
+     *     .derive(({ store }) => ({
+     *         increase() {
+     *             store.counter++
+     *         }
+     *     }))
+     */
+    resolve<const Resolver extends Record<string, unknown>>(resolver: (context: Prettify<Context<Metadata['schema'] & Ephemeral['schema'] & Volatile['schema'], Singleton & {
+        derive: Ephemeral['derive'] & Volatile['derive'];
+        resolve: Ephemeral['resolve'] & Volatile['resolve'];
+    }, BasePath>>) => MaybePromise<Resolver>): Elysia<BasePath, Scoped, Singleton, Definitions, Metadata, Routes, Ephemeral, {
+        derive: Volatile['resolve'];
+        resolve: Prettify<Volatile['resolve'] & ExcludeElysiaResponse<Resolver>>;
+        schema: Volatile['schema'];
+    }>;
+    mapResolve<const NewResolver extends Record<string, unknown>>(mapper: (context: Context<Metadata['schema'] & Ephemeral['schema'] & Volatile['schema'], Singleton & {
+        derive: Ephemeral['derive'] & Volatile['derive'];
+        resolve: Ephemeral['resolve'] & Volatile['resolve'];
+    }, BasePath>) => MaybePromise<NewResolver>): Elysia<BasePath, Scoped, Singleton, Definitions, Metadata, Routes, Ephemeral, {
+        derive: Volatile['derive'];
+        resolve: NewResolver;
+        schema: Volatile['schema'];
+    }>;
+    mapResolve<const NewResolver extends Record<string, unknown>, const Type extends LifeCycleType>(options: {
+        as?: Type;
+    }, mapper: (context: Context<Metadata['schema'] & Ephemeral['schema'] & Volatile['schema'], Singleton & ('global' extends Type ? {
+        derive: Partial<Ephemeral['derive'] & Volatile['derive']>;
+        resolve: Partial<Ephemeral['resolve'] & Volatile['resolve']>;
+    } : 'scoped' extends Type ? {
+        derive: Ephemeral['derive'] & Partial<Volatile['derive']>;
+        resolve: Ephemeral['resolve'] & Partial<Volatile['resolve']>;
+    } : {
+        derive: Ephemeral['derive'] & Volatile['derive'];
+        resolve: Ephemeral['resolve'] & Volatile['resolve'];
+    })>) => MaybePromise<NewResolver>): Type extends 'global' ? Elysia<BasePath, Scoped, {
+        decorator: Singleton['decorator'];
+        store: Singleton['store'];
+        derive: Singleton['resolve'];
+        resolve: Awaited<NewResolver>;
+    }, Definitions, Metadata, Routes, Ephemeral, Volatile> : Type extends 'scoped' ? Elysia<BasePath, Scoped, Singleton, Definitions, Metadata, Routes, {
+        derive: Ephemeral['resolve'];
+        resolve: Prettify<Ephemeral['resolve'] & ExcludeElysiaResponse<NewResolver>>;
+        schema: Ephemeral['schema'];
+    }, Volatile> : Elysia<BasePath, Scoped, Singleton, Definitions, Metadata, Routes, Ephemeral, {
+        derive: Volatile['resolve'];
+        resolve: Prettify<Volatile['resolve'] & ExcludeElysiaResponse<NewResolver>>;
+        schema: Volatile['schema'];
+    }>;
+    /**
+     * ### Before Handle | Life cycle event
+     * Execute after validation and before the main route handler.
+     *
+     * If truthy value is returned, will be assigned as `Response` and skip the main handler
+     *
+     * ---
+     * @example
+     * ```typescript
+     * new Elysia()
+     *     .onBeforeHandle(({ params: { id }, status }) => {
+     *         if(id && !isExisted(id)) {
+     * 	           status(401)
+     *
+     *             return "Unauthorized"
+     * 	       }
+     *     })
+     * ```
+     */
+    onBeforeHandle<const Schema extends RouteSchema>(handler: MaybeArray<OptionalHandler<MergeSchema<Schema, Metadata['schema'] & Ephemeral['schema'] & Volatile['schema']>, Singleton & {
+        derive: Ephemeral['derive'] & Volatile['derive'];
+        resolve: Ephemeral['resolve'] & Volatile['resolve'];
+    }>>): this;
+    /**
+     * ### Before Handle | Life cycle event
+     * Execute after validation and before the main route handler.
+     *
+     * If truthy value is returned, will be assigned as `Response` and skip the main handler
+     *
+     * ---
+     * @example
+     * ```typescript
+     * new Elysia()
+     *     .onBeforeHandle(({ params: { id }, status }) => {
+     *         if(id && !isExisted(id)) {
+     * 	           status(401)
+     *
+     *             return "Unauthorized"
+     * 	       }
+     *     })
+     * ```
+     */
+    onBeforeHandle<const Schema extends RouteSchema, const Type extends LifeCycleType>(options: {
+        as?: Type;
+    }, handler: MaybeArray<OptionalHandler<MergeSchema<Schema, Metadata['schema'] & Ephemeral['schema'] & Volatile['schema']>, Singleton & ('global' extends Type ? {
+        derive: Partial<Ephemeral['derive'] & Volatile['derive']>;
+        resolve: Partial<Ephemeral['resolve'] & Volatile['resolve']>;
+    } : 'scoped' extends Type ? {
+        derive: Ephemeral['derive'] & Partial<Volatile['derive']>;
+        resolve: Ephemeral['resolve'] & Partial<Volatile['resolve']>;
+    } : {
+        derive: Ephemeral['derive'] & Volatile['derive'];
+        resolve: Ephemeral['resolve'] & Volatile['resolve'];
+    }), BasePath>>): this;
+    /**
+     * ### After Handle | Life cycle event
+     * Intercept request **after** main handler is called.
+     *
+     * If truthy value is returned, will be assigned as `Response`
+     *
+     * ---
+     * @example
+     * ```typescript
+     * new Elysia()
+     *     .onAfterHandle((context, response) => {
+     *         if(typeof response === "object")
+     *             return JSON.stringify(response)
+     *     })
+     * ```
+     */
+    onAfterHandle<const Schema extends RouteSchema>(handler: MaybeArray<AfterHandler<MergeSchema<Schema, Metadata['schema'] & Ephemeral['schema'] & Volatile['schema']>, Singleton & {
+        derive: Ephemeral['derive'] & Volatile['derive'];
+        resolve: Ephemeral['resolve'] & Volatile['resolve'];
+    }, BasePath>>): this;
+    /**
+     * ### After Handle | Life cycle event
+     * Intercept request **after** main handler is called.
+     *
+     * If truthy value is returned, will be assigned as `Response`
+     *
+     * ---
+     * @example
+     * ```typescript
+     * new Elysia()
+     *     .onAfterHandle((context, response) => {
+     *         if(typeof response === "object")
+     *             return JSON.stringify(response)
+     *     })
+     * ```
+     */
+    onAfterHandle<const Schema extends RouteSchema, const Type extends LifeCycleType>(options: {
+        as?: LifeCycleType;
+    }, handler: MaybeArray<AfterHandler<MergeSchema<Schema, Metadata['schema'] & Ephemeral['schema'] & Volatile['schema']>, Singleton & ('global' extends Type ? {
+        derive: Partial<Ephemeral['derive'] & Volatile['derive']>;
+        resolve: Partial<Ephemeral['resolve'] & Volatile['resolve']>;
+    } : 'scoped' extends Type ? {
+        derive: Ephemeral['derive'] & Partial<Volatile['derive']>;
+        resolve: Ephemeral['resolve'] & Partial<Volatile['resolve']>;
+    } : {
+        derive: Ephemeral['derive'] & Volatile['derive'];
+        resolve: Ephemeral['resolve'] & Volatile['resolve'];
+    })>>): this;
+    /**
+     * ### After Handle | Life cycle event
+     * Intercept request **after** main handler is called.
+     *
+     * If truthy value is returned, will be assigned as `Response`
+     *
+     * ---
+     * @example
+     * ```typescript
+     * new Elysia()
+     *     .mapResponse((context, response) => {
+     *         if(typeof response === "object")
+     *             return JSON.stringify(response)
+     *     })
+     * ```
+     */
+    mapResponse<const Schema extends RouteSchema>(handler: MaybeArray<MapResponse<MergeSchema<Schema, Metadata['schema'] & Ephemeral['schema'] & Volatile['schema']>, Singleton & {
+        derive: Ephemeral['derive'] & Volatile['derive'];
+        resolve: Ephemeral['resolve'] & Volatile['resolve'];
+    }, BasePath>>): this;
+    /**
+     * ### After Handle | Life cycle event
+     * Intercept request **after** main handler is called.
+     *
+     * If truthy value is returned, will be assigned as `Response`
+     *
+     * ---
+     * @example
+     * ```typescript
+     * new Elysia()
+     *     .mapResponse((context, response) => {
+     *         if(typeof response === "object")
+     *             return JSON.stringify(response)
+     *     })
+     * ```
+     */
+    mapResponse<const Schema extends RouteSchema, Type extends LifeCycleType>(options: {
+        as?: Type;
+    }, handler: MaybeArray<MapResponse<MergeSchema<Schema, Metadata['schema'] & Ephemeral['schema'] & Volatile['schema']>, Singleton & ('global' extends Type ? {
+        derive: Partial<Ephemeral['derive'] & Volatile['derive']>;
+        resolve: Partial<Ephemeral['resolve'] & Volatile['resolve']>;
+    } : 'scoped' extends Type ? {
+        derive: Ephemeral['derive'] & Partial<Volatile['derive']>;
+        resolve: Ephemeral['resolve'] & Partial<Volatile['resolve']>;
+    } : {
+        derive: Ephemeral['derive'] & Volatile['derive'];
+        resolve: Ephemeral['resolve'] & Volatile['resolve'];
+    })>>): this;
+    /**
+     * ### response | Life cycle event
+     * Called when handler is executed
+     * Good for analytic metrics
+     *
+     * ---
+     * @example
+     * ```typescript
+     * new Elysia()
+     *     .onError(({ code }) => {
+     *         if(code === "NOT_FOUND")
+     *             return "Path not found :("
+     *     })
+     * ```
+     */
+    onResponse<const Schema extends RouteSchema>(handler: MaybeArray<VoidHandler<MergeSchema<Schema, Metadata['schema'] & Ephemeral['schema'] & Volatile['schema']>, Singleton & {
+        derive: Ephemeral['derive'] & Volatile['derive'];
+        resolve: Ephemeral['resolve'] & Volatile['resolve'];
+    }>>): this;
+    /**
+     * ### response | Life cycle event
+     * Called when handler is executed
+     * Good for analytic metrics
+     *
+     * ---
+     * @example
+     * ```typescript
+     * new Elysia()
+     *     .onError(({ code }) => {
+     *         if(code === "NOT_FOUND")
+     *             return "Path not found :("
+     *     })
+     * ```
+     */
+    onResponse<const Schema extends RouteSchema, const Type extends LifeCycleType>(options: {
+        as?: Type;
+    }, handler: MaybeArray<VoidHandler<MergeSchema<Schema, Metadata['schema'] & Ephemeral['schema'] & Volatile['schema']>, Singleton & ('global' extends Type ? {
+        derive: Partial<Ephemeral['derive'] & Volatile['derive']>;
+        resolve: Partial<Ephemeral['resolve'] & Volatile['resolve']>;
+    } : 'scoped' extends Type ? {
+        derive: Ephemeral['derive'] & Partial<Volatile['derive']>;
+        resolve: Ephemeral['resolve'] & Partial<Volatile['resolve']>;
+    } : {
+        derive: Ephemeral['derive'] & Volatile['derive'];
+        resolve: Ephemeral['resolve'] & Volatile['resolve'];
+    })>>): this;
+    /**
+     * ### After Handle | Life cycle event
+     * Intercept request **after** main handler is called.
+     *
+     * If truthy value is returned, will be assigned as `Response`
+     *
+     * ---
+     * @example
+     * ```typescript
+     * new Elysia()
+     *     .onAfterHandle((context, response) => {
+     *         if(typeof response === "object")
+     *             return JSON.stringify(response)
+     *     })
+     * ```
+     */
+    trace<const Schema extends RouteSchema>(handler: MaybeArray<TraceHandler<Schema, Singleton>>): this;
+    /**
+     * ### After Handle | Life cycle event
+     * Intercept request **after** main handler is called.
+     *
+     * If truthy value is returned, will be assigned as `Response`
+     *
+     * ---
+     * @example
+     * ```typescript
+     * new Elysia()
+     *     .onAfterHandle((context, response) => {
+     *         if(typeof response === "object")
+     *             return JSON.stringify(response)
+     *     })
+     * ```
+     */
+    trace<const Schema extends RouteSchema>(options: {
+        as?: LifeCycleType;
+    }, handler: MaybeArray<TraceHandler<Schema, Singleton>>): this;
+    /**
+     * Register errors
+     *
+     * ---
+     * @example
+     * ```typescript
+     * class CustomError extends Error {
+     *     constructor() {
+     *         super()
+     *     }
+     * }
+     *
+     * new Elysia()
+     *     .error('CUSTOM_ERROR', CustomError)
+     * ```
+     */
+    error<const Errors extends Record<string, {
+        prototype: Error;
+    }>>(errors: Errors): Elysia<BasePath, Scoped, Singleton, {
+        type: Definitions['type'];
+        error: Definitions['error'] & {
+            [K in keyof Errors]: Errors[K] extends {
+                prototype: infer LiteralError extends Error;
+            } ? LiteralError : Errors[K];
+        };
+    }, Metadata, Routes, Ephemeral, Volatile>;
+    /**
+     * Register errors
+     *
+     * ---
+     * @example
+     * ```typescript
+     * class CustomError extends Error {
+     *     constructor() {
+     *         super()
+     *     }
+     * }
+     *
+     * new Elysia()
+     *     .error({
+     *         CUSTOM_ERROR: CustomError
+     *     })
+     * ```
+     */
+    error<Name extends string, const CustomError extends {
+        prototype: Error;
+    }>(name: Name, errors: CustomError): Elysia<BasePath, Scoped, Singleton, {
+        type: Definitions['type'];
+        error: Definitions['error'] & {
+            [name in Name]: CustomError extends {
+                prototype: infer LiteralError extends Error;
+            } ? LiteralError : CustomError;
+        };
+    }, Metadata, Routes, Ephemeral, Volatile>;
+    /**
+     * Register errors
+     *
+     * ---
+     * @example
+     * ```typescript
+     * class CustomError extends Error {
+     *     constructor() {
+     *         super()
+     *     }
+     * }
+     *
+     * new Elysia()
+     *     .error('CUSTOM_ERROR', CustomError)
+     * ```
+     */
+    error<const NewErrors extends Record<string, Error>>(mapper: (decorators: Definitions['error']) => NewErrors): Elysia<BasePath, Scoped, Singleton, {
+        type: Definitions['type'];
+        error: {
+            [K in keyof NewErrors]: NewErrors[K] extends {
+                prototype: infer LiteralError extends Error;
+            } ? LiteralError : never;
+        };
+    }, Metadata, Routes, Ephemeral, Volatile>;
+    /**
+     * ### Error | Life cycle event
+     * Called when error is thrown during processing request
+     *
+     * ---
+     * @example
+     * ```typescript
+     * new Elysia()
+     *     .onError(({ code }) => {
+     *         if(code === "NOT_FOUND")
+     *             return "Path not found :("
+     *     })
+     * ```
+     */
+    onError<const Schema extends RouteSchema>(handler: ErrorHandler<Definitions['error'], MergeSchema<Schema, Metadata['schema'] & Ephemeral['schema'] & Volatile['schema']>, Singleton>): this;
+    /**
+     * ### Error | Life cycle event
+     * Called when error is thrown during processing request
+     *
+     * ---
+     * @example
+     * ```typescript
+     * new Elysia()
+     *     .onError(({ code }) => {
+     *         if(code === "NOT_FOUND")
+     *             return "Path not found :("
+     *     })
+     * ```
+     */
+    onError<const Schema extends RouteSchema>(options: {
+        as?: LifeCycleType;
+    }, handler: ErrorHandler<Definitions['error'], MergeSchema<Schema, Metadata['schema'] & Ephemeral['schema'] & Volatile['schema']>, Singleton>): this;
+    /**
+     * ### stop | Life cycle event
+     * Called after server stop serving request
+     *
+     * ---
+     * @example
+     * ```typescript
+     * new Elysia()
+     *     .onStop((app) => {
+     *         cleanup()
+     *     })
+     * ```
+     */
+    onStop(handler: MaybeArray<GracefulHandler<this>>): this;
+    /**
+     * ### on
+     * Syntax sugar for attaching life cycle event by name
+     *
+     * Does the exact same thing as `.on[Event]()`
+     *
+     * ---
+     * @example
+     * ```typescript
+     * new Elysia()
+     *     .on('error', ({ code }) => {
+     *         if(code === "NOT_FOUND")
+     *             return "Path not found :("
+     *     })
+     * ```
+     */
+    on<Event extends keyof LifeCycleStore>(type: Exclude<Event, 'onResponse'> | 'response', handlers: MaybeArray<Extract<LifeCycleStore[Event], Function[]>[0]>): this;
+    /**
+     * ### on
+     * Syntax sugar for attaching life cycle event by name
+     *
+     * Does the exact same thing as `.on[Event]()`
+     *
+     * ---
+     * @example
+     * ```typescript
+     * new Elysia()
+     *     .on('error', ({ code }) => {
+     *         if(code === "NOT_FOUND")
+     *             return "Path not found :("
+     *     })
+     * ```
+     */
+    on<const Event extends keyof LifeCycleStore>(options: {
+        as?: LifeCycleType;
+    }, type: Exclude<Event, 'onResponse'> | 'response', handlers: MaybeArray<Extract<LifeCycleStore[Event], Function[]>[0]>): this;
+    group<const Prefix extends string, const NewElysia extends Elysia<any, any, any, any, any, any, any, any>>(prefix: Prefix, run: (group: Elysia<`${BasePath}${Prefix}`, Scoped, Singleton, Definitions, Metadata, {}, Ephemeral, Volatile>) => NewElysia): Elysia<BasePath, Scoped, Singleton, Definitions, Metadata, Prettify<Routes & NewElysia['_routes']>, Ephemeral, Volatile>;
+    group<const Prefix extends string, const NewElysia extends Elysia<any, any, any, any, any, any, any, any>, const Input extends InputSchema<Extract<keyof Definitions['type'], string>>, const Schema extends MergeSchema<UnwrapRoute<Input, Definitions['type']>, Metadata['schema']>>(prefix: Prefix, schema: LocalHook<Input, Schema, Singleton & {
+        derive: Ephemeral['derive'] & Volatile['derive'];
+        resolve: Ephemeral['resolve'] & Volatile['resolve'];
+    }, Definitions['error'], Metadata['macro'], `${BasePath}${Prefix}`>, run: (group: Elysia<`${BasePath}${Prefix}`, false, Singleton, Definitions, {
+        schema: Schema;
+        macro: Metadata['macro'];
+    }, {}, Ephemeral, Volatile>) => NewElysia): Elysia<BasePath, Scoped, Singleton, Definitions, Metadata, Routes & NewElysia['_routes'], Ephemeral, Volatile>;
+    guard<const LocalSchema extends InputSchema<Extract<keyof Definitions['type'], string>>, const Schema extends MergeSchema<UnwrapRoute<LocalSchema, Definitions['type']>, Metadata['schema']>>(hook: LocalHook<LocalSchema, Schema, Singleton & {
+        derive: Ephemeral['derive'] & Volatile['derive'];
+        resolve: Ephemeral['resolve'] & Volatile['resolve'];
+    }, Definitions['error'], Metadata['macro'], BasePath>): Elysia<BasePath, Scoped, Singleton, Definitions, Metadata, Routes, Ephemeral, {
+        derive: Volatile['resolve'];
+        resolve: Volatile['resolve'];
+        schema: MergeSchema<UnwrapRoute<LocalSchema, Definitions['type']>, Metadata['schema'] & Ephemeral['schema'] & Volatile['schema']>;
+    }>;
+    guard<const LocalSchema extends InputSchema<Extract<keyof Definitions['type'], string>>, const NewElysia extends Elysia<any, any, any, any, any, any, any, any>, const Schema extends MergeSchema<UnwrapRoute<LocalSchema, Definitions['type']>, Metadata['schema']>>(run: (group: Elysia<BasePath, Scoped, Singleton, Definitions, {
+        schema: Prettify<Schema>;
+        macro: Metadata['macro'];
+    }, {}, Ephemeral, Volatile>) => NewElysia): Elysia<BasePath, Scoped, Singleton, Definitions, Metadata, Prettify<Routes & NewElysia['_routes']>, Ephemeral, Volatile>;
+    guard<const LocalSchema extends InputSchema<Extract<keyof Definitions['type'], string>>, const NewElysia extends Elysia<any, any, any, any, any, any, any, any>, const Schema extends MergeSchema<UnwrapRoute<LocalSchema, Definitions['type']>, Metadata['schema']>>(schema: LocalHook<LocalSchema, Schema, Singleton & {
+        derive: Ephemeral['derive'] & Volatile['derive'];
+        resolve: Ephemeral['resolve'] & Volatile['resolve'];
+    }, Definitions['error'], Metadata['macro'], ''>, run: (group: Elysia<BasePath, Scoped, Singleton, Definitions, {
+        schema: Prettify<Schema>;
+        macro: Metadata['macro'];
+    }, {}, Ephemeral, Volatile>) => NewElysia): Elysia<BasePath, Scoped, Singleton, Definitions, Metadata, Prettify<Routes & NewElysia['_routes']>, Ephemeral, Volatile>;
+    /**
+     * Inline fn
+     */
+    use<const NewElysia extends Elysia<any, any, any, any, any, any, any, any>, const Param extends Elysia<any, any, any, any, any, any, any, any> = this>(plugin: MaybePromise<(app: Param) => MaybePromise<NewElysia>>): NewElysia['_scoped'] extends false ? Elysia<BasePath, Scoped, Prettify2<Singleton & NewElysia['_types']['Singleton']>, Prettify2<Definitions & NewElysia['_types']['Definitions']>, Prettify2<Metadata & NewElysia['_types']['Metadata']>, BasePath extends `` ? Routes & NewElysia['_routes'] : Routes & CreateEden<BasePath, NewElysia['_routes']>, Prettify<Ephemeral & NewElysia['_ephemeral']>, Prettify2<Volatile & NewElysia['_volatile']>> : Elysia<BasePath, Scoped, Singleton, Definitions, Metadata, BasePath extends `` ? Routes & NewElysia['_routes'] : Routes & CreateEden<BasePath, NewElysia['_routes']>, Ephemeral, Volatile>;
+    /**
+     * Entire Instance
+     **/
+    use<const NewElysia extends Elysia<any, any, any, any, any, any, any, any>>(instance: MaybePromise<NewElysia>): NewElysia['_scoped'] extends false ? Elysia<BasePath, Scoped, Prettify2<Singleton & NewElysia['_types']['Singleton']>, Prettify2<Definitions & NewElysia['_types']['Definitions']>, Prettify2<Metadata & NewElysia['_types']['Metadata']>, BasePath extends `` ? Routes & NewElysia['_routes'] : Routes & CreateEden<BasePath, NewElysia['_routes']>, Ephemeral, Prettify2<Volatile & NewElysia['_ephemeral']>> : Elysia<BasePath, Scoped, Singleton, Definitions, Metadata, BasePath extends `` ? Routes & NewElysia['_routes'] : Routes & CreateEden<BasePath, NewElysia['_routes']>, Ephemeral, Volatile>;
+    /**
+     * Import fn
+     */
+    use<const NewElysia extends Elysia<any, any, any, any, any, any, any, any>>(plugin: Promise<{
+        default: (elysia: Elysia<any, any, any, any, any, any, any, any>) => MaybePromise<NewElysia>;
+    }>): NewElysia['_scoped'] extends false ? Elysia<BasePath, Scoped, Prettify2<Singleton & NewElysia['_types']['Singleton']>, Prettify2<Definitions & NewElysia['_types']['Definitions']>, Prettify2<Metadata & NewElysia['_types']['Metadata']>, BasePath extends `` ? Routes & NewElysia['_routes'] : Routes & CreateEden<BasePath, NewElysia['_routes']>, Prettify2<Ephemeral & NewElysia['_ephemeral']>, Prettify2<Volatile & NewElysia['_volatile']>> : Elysia<BasePath, Scoped, Singleton, Definitions, Metadata, BasePath extends `` ? Routes & NewElysia['_routes'] : Routes & CreateEden<BasePath, NewElysia['_routes']>, Ephemeral, Volatile>;
+    /**
+     * Import entire instance
+     */
+    use<const LazyLoadElysia extends Elysia<any, any, any, any, any, any, any, any>>(plugin: Promise<{
+        default: LazyLoadElysia;
+    }>): LazyLoadElysia['_scoped'] extends false ? Elysia<BasePath, Scoped, Prettify2<Singleton & LazyLoadElysia['_types']['Singleton']>, Prettify2<Definitions & LazyLoadElysia['_types']['Definitions']>, Prettify2<Metadata & LazyLoadElysia['_types']['Metadata']>, BasePath extends `` ? Routes & LazyLoadElysia['_routes'] : Routes & CreateEden<BasePath, LazyLoadElysia['_routes']>, Ephemeral, Prettify2<Volatile & LazyLoadElysia['_ephemeral']>> : Elysia<BasePath, Scoped, Singleton, Definitions, Metadata, BasePath extends `` ? Routes & LazyLoadElysia['_routes'] : Routes & CreateEden<BasePath, LazyLoadElysia['_routes']>, Ephemeral, Volatile>;
+    private _use;
+    macro<const NewMacro extends BaseMacro>(macro: (route: MacroManager<Metadata['schema'] & Ephemeral['schema'] & Volatile['schema'], Singleton & {
+        derive: Partial<Ephemeral['derive'] & Volatile['derive']>;
+        resolve: Partial<Ephemeral['resolve'] & Volatile['resolve']>;
+    }, Definitions['error']>) => NewMacro): Elysia<BasePath, Scoped, Singleton, Definitions, {
+        schema: Metadata['schema'];
+        macro: Metadata['macro'] & Partial<MacroToProperty<NewMacro>>;
+    }, Routes, Ephemeral, Volatile>;
+    mount(handle: ((request: Request) => MaybePromise<Response>) | Elysia<any, any, any, any, any, any, any, any>): this;
+    mount(path: string, handle: ((request: Request) => MaybePromise<Response>) | Elysia<any, any, any, any, any, any, any, any>): this;
+    /**
+     * ### get
+     * Register handler for path with method [GET]
+     *
+     * ---
+     * @example
+     * ```typescript
+     * import { Elysia, t } from 'elysia'
+     *
+     * new Elysia()
+     *     .get('/', () => 'hi')
+     *     .get('/with-hook', () => 'hi', {
+     *         response: t.String()
+     *     })
+     * ```
+     */
+    get<const Path extends string, const LocalSchema extends InputSchema<keyof Definitions['type'] & string>, const Schema extends MergeSchema<UnwrapRoute<LocalSchema, Definitions['type']>, Metadata['schema'] & Ephemeral['schema'] & Volatile['schema']>, const Handle extends InlineHandler<Schema, Singleton & {
+        derive: Ephemeral['derive'] & Volatile['derive'];
+        resolve: Ephemeral['resolve'] & Volatile['resolve'];
+    }, `${BasePath}${Path extends '/' ? '' : Path}`>>(path: Path, handler: Handle, hook?: LocalHook<LocalSchema, Schema, Singleton & {
+        derive: Ephemeral['derive'] & Volatile['derive'];
+        resolve: Ephemeral['resolve'] & Volatile['resolve'];
+    }, Definitions['error'], Metadata['macro'], `${BasePath}${Path extends '/' ? '/index' : Path}`>): Elysia<BasePath, Scoped, Singleton, Definitions, Metadata, Routes & CreateEden<`${BasePath & string}${Path extends '/' ? '/index' : Path}`, {
+        get: {
+            body: Schema['body'];
+            params: undefined extends Schema['params'] ? Record<GetPathParameter<Path>, string> : Schema['params'];
+            query: Schema['query'];
+            headers: Schema['headers'];
+            response: ComposeElysiaResponse<Schema['response'], Handle>;
+        };
+    }>, Ephemeral, Volatile>;
+    /**
+     * ### post
+     * Register handler for path with method [POST]
+     *
+     * ---
+     * @example
+     * ```typescript
+     * import { Elysia, t } from 'elysia'
+     *
+     * new Elysia()
+     *     .post('/', () => 'hi')
+     *     .post('/with-hook', () => 'hi', {
+     *         response: t.String()
+     *     })
+     * ```
+     */
+    post<const Path extends string, const LocalSchema extends InputSchema<keyof Definitions['type'] & string>, const Schema extends MergeSchema<UnwrapRoute<LocalSchema, Definitions['type']>, Metadata['schema'] & Ephemeral['schema'] & Volatile['schema']>, const Handle extends InlineHandler<Schema, Singleton & {
+        derive: Ephemeral['derive'] & Volatile['derive'];
+        resolve: Ephemeral['resolve'] & Volatile['resolve'];
+    }, `${BasePath}${Path extends '/' ? '/index' : Path}`>>(path: Path, handler: Handle, hook?: LocalHook<LocalSchema, Schema, Singleton & {
+        derive: Ephemeral['derive'] & Volatile['derive'];
+        resolve: Ephemeral['resolve'] & Volatile['resolve'];
+    }, Definitions['error'], Metadata['macro'], `${BasePath}${Path extends '/' ? '/index' : Path}`>): Elysia<BasePath, Scoped, Singleton, Definitions, Metadata, Routes & CreateEden<`${BasePath & string}${Path extends '/' ? '/index' : Path}`, {
+        post: {
+            body: Schema['body'];
+            params: undefined extends Schema['params'] ? Record<GetPathParameter<Path>, string> : Schema['params'];
+            query: Schema['query'];
+            headers: Schema['headers'];
+            response: ComposeElysiaResponse<Schema['response'], Handle>;
+        };
+    }>, Ephemeral, Volatile>;
+    /**
+     * ### put
+     * Register handler for path with method [PUT]
+     *
+     * ---
+     * @example
+     * ```typescript
+     * import { Elysia, t } from 'elysia'
+     *
+     * new Elysia()
+     *     .put('/', () => 'hi')
+     *     .put('/with-hook', () => 'hi', {
+     *         response: t.String()
+     *     })
+     * ```
+     */
+    put<const Path extends string, const LocalSchema extends InputSchema<keyof Definitions['type'] & string>, const Schema extends MergeSchema<UnwrapRoute<LocalSchema, Definitions['type']>, Metadata['schema'] & Ephemeral['schema'] & Volatile['schema']>, const Handle extends InlineHandler<Schema, Singleton & {
+        derive: Ephemeral['derive'] & Volatile['derive'];
+        resolve: Ephemeral['resolve'] & Volatile['resolve'];
+    }, `${BasePath}${Path extends '/' ? '/index' : Path}`>>(path: Path, handler: Handle, hook?: LocalHook<LocalSchema, Schema, Singleton & {
+        derive: Ephemeral['derive'] & Volatile['derive'];
+        resolve: Ephemeral['resolve'] & Volatile['resolve'];
+    }, Definitions['error'], Metadata['macro'], `${BasePath}${Path extends '/' ? '/index' : Path}`>): Elysia<BasePath, Scoped, Singleton, Definitions, Metadata, Routes & CreateEden<`${BasePath & string}${Path extends '/' ? '/index' : Path}`, {
+        put: {
+            body: Schema['body'];
+            params: undefined extends Schema['params'] ? Record<GetPathParameter<Path>, string> : Schema['params'];
+            query: Schema['query'];
+            headers: Schema['headers'];
+            response: ComposeElysiaResponse<Schema['response'], Handle>;
+        };
+    }>, Ephemeral, Volatile>;
+    /**
+     * ### patch
+     * Register handler for path with method [PATCH]
+     *
+     * ---
+     * @example
+     * ```typescript
+     * import { Elysia, t } from 'elysia'
+     *
+     * new Elysia()
+     *     .patch('/', () => 'hi')
+     *     .patch('/with-hook', () => 'hi', {
+     *         response: t.String()
+     *     })
+     * ```
+     */
+    patch<const Path extends string, const LocalSchema extends InputSchema<keyof Definitions['type'] & string>, const Schema extends MergeSchema<UnwrapRoute<LocalSchema, Definitions['type']>, Metadata['schema'] & Ephemeral['schema'] & Volatile['schema']>, const Handle extends InlineHandler<Schema, Singleton & {
+        derive: Ephemeral['derive'] & Volatile['derive'];
+        resolve: Ephemeral['resolve'] & Volatile['resolve'];
+    }, `${BasePath}${Path extends '/' ? '/index' : Path}`>>(path: Path, handler: Handle, hook?: LocalHook<LocalSchema, Schema, Singleton & {
+        derive: Ephemeral['derive'] & Volatile['derive'];
+        resolve: Ephemeral['resolve'] & Volatile['resolve'];
+    }, Definitions['error'], Metadata['macro'], `${BasePath}${Path extends '/' ? '/index' : Path}`>): Elysia<BasePath, Scoped, Singleton, Definitions, Metadata, Routes & CreateEden<`${BasePath & string}${Path extends '/' ? '/index' : Path}`, {
+        patch: {
+            body: Schema['body'];
+            params: undefined extends Schema['params'] ? Record<GetPathParameter<Path>, string> : Schema['params'];
+            query: Schema['query'];
+            headers: Schema['headers'];
+            response: ComposeElysiaResponse<Schema['response'], Handle>;
+        };
+    }>, Ephemeral, Volatile>;
+    /**
+     * ### delete
+     * Register handler for path with method [DELETE]
+     *
+     * ---
+     * @example
+     * ```typescript
+     * import { Elysia, t } from 'elysia'
+     *
+     * new Elysia()
+     *     .delete('/', () => 'hi')
+     *     .delete('/with-hook', () => 'hi', {
+     *         response: t.String()
+     *     })
+     * ```
+     */
+    delete<const Path extends string, const LocalSchema extends InputSchema<keyof Definitions['type'] & string>, const Schema extends MergeSchema<UnwrapRoute<LocalSchema, Definitions['type']>, Metadata['schema'] & Ephemeral['schema'] & Volatile['schema']>, const Handle extends InlineHandler<Schema, Singleton & {
+        derive: Ephemeral['derive'] & Volatile['derive'];
+        resolve: Ephemeral['resolve'] & Volatile['resolve'];
+    }, `${BasePath}${Path extends '/' ? '/index' : Path}`>>(path: Path, handler: Handle, hook?: LocalHook<LocalSchema, Schema, Singleton & {
+        derive: Ephemeral['derive'] & Volatile['derive'];
+        resolve: Ephemeral['resolve'] & Volatile['resolve'];
+    }, Definitions['error'], Metadata['macro'], `${BasePath}${Path extends '/' ? '/index' : Path}`>): Elysia<BasePath, Scoped, Singleton, Definitions, Metadata, Routes & CreateEden<`${BasePath & string}${Path extends '/' ? '/index' : Path}`, {
+        delete: {
+            body: Schema['body'];
+            params: undefined extends Schema['params'] ? Record<GetPathParameter<Path>, string> : Schema['params'];
+            query: Schema['query'];
+            headers: Schema['headers'];
+            response: ComposeElysiaResponse<Schema['response'], Handle>;
+        };
+    }>, Ephemeral, Volatile>;
+    /**
+     * ### options
+     * Register handler for path with method [POST]
+     *
+     * ---
+     * @example
+     * ```typescript
+     * import { Elysia, t } from 'elysia'
+     *
+     * new Elysia()
+     *     .options('/', () => 'hi')
+     *     .options('/with-hook', () => 'hi', {
+     *         response: t.String()
+     *     })
+     * ```
+     */
+    options<const Path extends string, const LocalSchema extends InputSchema<keyof Definitions['type'] & string>, const Schema extends MergeSchema<UnwrapRoute<LocalSchema, Definitions['type']>, Metadata['schema'] & Ephemeral['schema'] & Volatile['schema']>, const Handle extends InlineHandler<Schema, Singleton & {
+        derive: Ephemeral['derive'] & Volatile['derive'];
+        resolve: Ephemeral['resolve'] & Volatile['resolve'];
+    }, `${BasePath}${Path extends '/' ? '/index' : Path}`>>(path: Path, handler: Handle, hook?: LocalHook<LocalSchema, Schema, Singleton & {
+        derive: Ephemeral['derive'] & Volatile['derive'];
+        resolve: Ephemeral['resolve'] & Volatile['resolve'];
+    }, Definitions['error'], Metadata['macro'], `${BasePath}${Path extends '/' ? '/index' : Path}`>): Elysia<BasePath, Scoped, Singleton, Definitions, Metadata, Routes & CreateEden<`${BasePath & string}${Path extends '/' ? '/index' : Path}`, {
+        options: {
+            body: Schema['body'];
+            params: undefined extends Schema['params'] ? Record<GetPathParameter<Path>, string> : Schema['params'];
+            query: Schema['query'];
+            headers: Schema['headers'];
+            response: ComposeElysiaResponse<Schema['response'], Handle>;
+        };
+    }>, Ephemeral, Volatile>;
+    /**
+     * ### all
+     * Register handler for path with method [ALL]
+     *
+     * ---
+     * @example
+     * ```typescript
+     * import { Elysia, t } from 'elysia'
+     *
+     * new Elysia()
+     *     .all('/', () => 'hi')
+     *     .all('/with-hook', () => 'hi', {
+     *         response: t.String()
+     *     })
+     * ```
+     */
+    all<const Path extends string, const LocalSchema extends InputSchema<keyof Definitions['type'] & string>, const Schema extends MergeSchema<UnwrapRoute<LocalSchema, Definitions['type']>, Metadata['schema'] & Ephemeral['schema'] & Volatile['schema']>, const Handle extends InlineHandler<Schema, Singleton & {
+        derive: Ephemeral['derive'] & Volatile['derive'];
+        resolve: Ephemeral['resolve'] & Volatile['resolve'];
+    }, `${BasePath}${Path extends '/' ? '/index' : Path}`>>(path: Path, handler: Handle, hook?: LocalHook<LocalSchema, Schema, Singleton & {
+        derive: Ephemeral['derive'] & Volatile['derive'];
+        resolve: Ephemeral['resolve'] & Volatile['resolve'];
+    }, Definitions['error'], Metadata['macro'], `${BasePath}${Path extends '/' ? '/index' : Path}`>): Elysia<BasePath, Scoped, Singleton, Definitions, Metadata, Routes & CreateEden<`${BasePath & string}${Path extends '/' ? '/index' : Path}`, {
+        [method in string]: {
+            body: Schema['body'];
+            params: undefined extends Schema['params'] ? Record<GetPathParameter<Path>, string> : Schema['params'];
+            query: Schema['query'];
+            headers: Schema['headers'];
+            response: ComposeElysiaResponse<Schema['response'], Handle>;
+        };
+    }>, Ephemeral, Volatile>;
+    /**
+     * ### head
+     * Register handler for path with method [HEAD]
+     *
+     * ---
+     * @example
+     * ```typescript
+     * import { Elysia, t } from 'elysia'
+     *
+     * new Elysia()
+     *     .head('/', () => 'hi')
+     *     .head('/with-hook', () => 'hi', {
+     *         response: t.String()
+     *     })
+     * ```
+     */
+    head<const Path extends string, const LocalSchema extends InputSchema<keyof Definitions['type'] & string>, const Schema extends MergeSchema<UnwrapRoute<LocalSchema, Definitions['type']>, Metadata['schema'] & Ephemeral['schema'] & Volatile['schema']>, const Handle extends InlineHandler<Schema, Singleton & {
+        derive: Ephemeral['derive'] & Volatile['derive'];
+        resolve: Ephemeral['resolve'] & Volatile['resolve'];
+    }, `${BasePath}${Path extends '/' ? '/index' : Path}`>>(path: Path, handler: Handle, hook?: LocalHook<LocalSchema, Schema, Singleton & {
+        derive: Ephemeral['derive'] & Volatile['derive'];
+        resolve: Ephemeral['resolve'] & Volatile['resolve'];
+    }, Definitions['error'], Metadata['macro'], `${BasePath}${Path extends '/' ? '/index' : Path}`>): Elysia<BasePath, Scoped, Singleton, Definitions, Metadata, Routes & CreateEden<`${BasePath & string}${Path extends '/' ? '/index' : Path}`, {
+        head: {
+            body: Schema['body'];
+            params: undefined extends Schema['params'] ? Record<GetPathParameter<Path>, string> : Schema['params'];
+            query: Schema['query'];
+            headers: Schema['headers'];
+            response: ComposeElysiaResponse<Schema['response'], Handle>;
+        };
+    }>, Ephemeral, Volatile>;
+    /**
+     * ### connect
+     * Register handler for path with method [CONNECT]
+     *
+     * ---
+     * @example
+     * ```typescript
+     * import { Elysia, t } from 'elysia'
+     *
+     * new Elysia()
+     *     .connect('/', () => 'hi')
+     *     .connect('/with-hook', () => 'hi', {
+     *         response: t.String()
+     *     })
+     * ```
+     */
+    connect<const Path extends string, const LocalSchema extends InputSchema<keyof Definitions['type'] & string>, const Schema extends MergeSchema<UnwrapRoute<LocalSchema, Definitions['type']>, Metadata['schema'] & Ephemeral['schema'] & Volatile['schema']>, const Handle extends InlineHandler<Schema, Singleton & {
+        derive: Ephemeral['derive'] & Volatile['derive'];
+        resolve: Ephemeral['resolve'] & Volatile['resolve'];
+    }, `${BasePath}${Path extends '/' ? '/index' : Path}`>>(path: Path, handler: Handle, hook?: LocalHook<LocalSchema, Schema, Singleton & {
+        derive: Ephemeral['derive'] & Volatile['derive'];
+        resolve: Ephemeral['resolve'] & Volatile['resolve'];
+    }, Definitions['error'], Metadata['macro'], `${BasePath}${Path extends '/' ? '/index' : Path}`>): Elysia<BasePath, Scoped, Singleton, Definitions, Metadata, Routes & CreateEden<`${BasePath & string}${Path extends '/' ? '/index' : Path}`, {
+        connect: {
+            body: Schema['body'];
+            params: undefined extends Schema['params'] ? Record<GetPathParameter<Path>, string> : Schema['params'];
+            query: Schema['query'];
+            headers: Schema['headers'];
+            response: ComposeElysiaResponse<Schema['response'], Handle>;
+        };
+    }>, Ephemeral, Volatile>;
+    /**
+     * ### route
+     * Register handler for path with method [ROUTE]
+     *
+     * ---
+     * @example
+     * ```typescript
+     * import { Elysia, t } from 'elysia'
+     *
+     * new Elysia()
+     *     .route('/', () => 'hi')
+     *     .route('/with-hook', () => 'hi', {
+     *         response: t.String()
+     *     })
+     * ```
+     */
+    route<const Method extends HTTPMethod, const Path extends string, const LocalSchema extends InputSchema<keyof Definitions['type'] & string>, const Schema extends MergeSchema<UnwrapRoute<LocalSchema, Definitions['type']>, Metadata['schema'] & Ephemeral['schema'] & Volatile['schema']>, const Handle extends InlineHandler<Schema, Singleton & {
+        derive: Ephemeral['derive'] & Volatile['derive'];
+        resolve: Ephemeral['resolve'] & Volatile['resolve'];
+    }, `${BasePath}${Path extends '/' ? '/index' : Path}`>>(method: Method, path: Path, handler: Handle, hook?: LocalHook<LocalSchema, Schema, Singleton & {
+        derive: Ephemeral['derive'] & Volatile['derive'];
+        resolve: Ephemeral['resolve'] & Volatile['resolve'];
+    }, Definitions['error'], Metadata['macro'], `${BasePath}${Path extends '/' ? '/index' : Path}`> & {
+        config: {
+            allowMeta?: boolean;
+        };
+    }): Elysia<BasePath, Scoped, Singleton, Definitions, Metadata, Routes & CreateEden<`${BasePath & string}${Path extends '/' ? '/index' : Path}`, {
+        [method in Method]: {
+            body: Schema['body'];
+            params: undefined extends Schema['params'] ? Record<GetPathParameter<Path>, string> : Schema['params'];
+            query: Schema['query'];
+            headers: Schema['headers'];
+            response: ComposeElysiaResponse<Schema['response'], Handle>;
+        };
+    }>, Ephemeral, Volatile>;
+    /**
+     * ### ws
+     * Register handler for path with method [ws]
+     *
+     * ---
+     * @example
+     * ```typescript
+     * import { Elysia, t } from 'elysia'
+     *
+     * new Elysia()
+     *     .ws('/', {
+     *         message(ws, message) {
+     *             ws.send(message)
+     *         }
+     *     })
+     * ```
+     */
+    ws<const Path extends string, const LocalSchema extends InputSchema<keyof Definitions['type'] & string>, const Schema extends MergeSchema<UnwrapRoute<LocalSchema, Definitions['type']>, Metadata['schema']>>(path: Path, options: WS.LocalHook<LocalSchema, Schema, Singleton & {
+        derive: Ephemeral['derive'] & Volatile['derive'];
+        resolve: Ephemeral['resolve'] & Volatile['resolve'];
+    }, Definitions['error'], Metadata['macro'], `${BasePath}${Path extends '/' ? '/index' : Path}`>): Elysia<BasePath, Scoped, Singleton, Definitions, Metadata, Routes & CreateEden<`${BasePath}${Path extends '/' ? '/index' : Path}`, {
+        subscribe: {
+            body: Schema['body'];
+            params: undefined extends Schema['params'] ? Record<GetPathParameter<Path>, string> : Schema['params'];
+            query: Schema['query'];
+            headers: Schema['headers'];
+            response: Schema['response'];
+        };
+    }>, Ephemeral, Volatile>;
+    /**
+     * ### state
+     * Assign global mutatable state accessible for all handler
+     *
+     * ---
+     * @example
+     * ```typescript
+     * new Elysia()
+     *     .state({ counter: 0 })
+     *     .get('/', (({ counter }) => ++counter)
+     * ```
+     */
+    state<const Name extends string | number | symbol, Value>(name: Name, value: Value): Elysia<BasePath, Scoped, {
+        decorator: Singleton['decorator'];
+        store: Prettify<Singleton['store'] & {
+            [name in Name]: Value;
+        }>;
+        derive: Singleton['derive'];
+        resolve: Singleton['resolve'];
+    }, Definitions, Metadata, Routes, Ephemeral, Volatile>;
+    /**
+     * ### state
+     * Assign global mutatable state accessible for all handler
+     *
+     * ---
+     * @example
+     * ```typescript
+     * new Elysia()
+     *     .state('counter', 0)
+     *     .get('/', (({ counter }) => ++counter)
+     * ```
+     */
+    state<Store extends Record<string, unknown>>(store: Store): Elysia<BasePath, Scoped, {
+        decorator: Singleton['decorator'];
+        store: Prettify<Singleton['store'] & Store>;
+        derive: Singleton['derive'];
+        resolve: Singleton['resolve'];
+    }, Definitions, Metadata, Routes, Ephemeral, Volatile>;
+    state<NewStore extends Record<string, unknown>>(mapper: (decorators: Singleton['store']) => NewStore): Elysia<BasePath, Scoped, {
+        decorator: Singleton['decorator'];
+        store: NewStore;
+        derive: Singleton['derive'];
+        resolve: Singleton['resolve'];
+    }, Definitions, Metadata, Routes, Ephemeral, Volatile>;
+    /**
+     * ### decorate
+     * Define custom method to `Context` accessible for all handler
+     *
+     * ---
+     * @example
+     * ```typescript
+     * new Elysia()
+     *     .decorate('getDate', () => Date.now())
+     *     .get('/', (({ getDate }) => getDate())
+     * ```
+     */
+    decorate<const Name extends string, const Value>(name: Name, value: Value): Elysia<BasePath, Scoped, {
+        decorator: Prettify<Singleton['decorator'] & {
+            [name in Name]: Value;
+        }>;
+        store: Singleton['store'];
+        derive: Singleton['derive'];
+        resolve: Singleton['resolve'];
+    }, Definitions, Metadata, Routes, Ephemeral, Volatile>;
+    /**
+     * ### decorate
+     * Define custom method to `Context` accessible for all handler
+     *
+     * ---
+     * @example
+     * ```typescript
+     * new Elysia()
+     *     .decorate('getDate', () => Date.now())
+     *     .get('/', (({ getDate }) => getDate())
+     * ```
+     */
+    decorate<const NewDecorators extends Record<string, unknown>>(decorators: NewDecorators): Elysia<BasePath, Scoped, {
+        decorator: Prettify<Singleton['decorator'] & NewDecorators>;
+        store: Singleton['store'];
+        derive: Singleton['derive'];
+        resolve: Singleton['resolve'];
+    }, Definitions, Metadata, Routes, Ephemeral, Volatile>;
+    decorate<const NewDecorators extends Record<string, unknown>>(mapper: (decorators: Singleton['decorator']) => NewDecorators): Elysia<BasePath, Scoped, {
+        decorator: NewDecorators;
+        store: Singleton['store'];
+        derive: Singleton['derive'];
+        resolve: Singleton['resolve'];
+    }, Definitions, Metadata, Routes, Ephemeral, Volatile>;
+    /**
+     * Derive new property for each request with access to `Context`.
+     *
+     * If error is thrown, the scope will skip to handling error instead.
+     *
+     * ---
+     * @example
+     * new Elysia()
+     *     .state('counter', 1)
+     *     .derive(({ store }) => ({
+     *         increase() {
+     *             store.counter++
+     *         }
+     *     }))
+     */
+    derive<const Derivative extends Record<string, unknown>>(transform: (context: Prettify<Context<Metadata['schema'] & Ephemeral['schema'] & Volatile['schema'], Singleton & {
+        derive: Ephemeral['derive'] & Volatile['derive'];
+        resolve: Ephemeral['resolve'] & Volatile['resolve'];
+    }>>) => MaybePromise<Derivative>): Elysia<BasePath, Scoped, Singleton, Definitions, Metadata, Routes, Ephemeral, {
+        derive: Prettify<Volatile['derive'] & ExcludeElysiaResponse<Derivative>>;
+        resolve: Volatile['resolve'];
+        schema: Volatile['schema'];
+    }>;
+    /**
+     * Derive new property for each request with access to `Context`.
+     *
+     * If error is thrown, the scope will skip to handling error instead.
+     *
+     * ---
+     * @example
+     * new Elysia()
+     *     .state('counter', 1)
+     *     .derive(({ store }) => ({
+     *         increase() {
+     *             store.counter++
+     *         }
+     *     }))
+     */
+    derive<const Derivative extends Record<string, unknown>, const Type extends LifeCycleType>(options: {
+        as?: Type;
+    }, transform: (context: Prettify<Context<Metadata['schema'] & Ephemeral['schema'] & Volatile['schema'], Singleton & ('global' extends Type ? {
+        derive: Partial<Ephemeral['derive'] & Volatile['derive']>;
+        resolve: Partial<Ephemeral['resolve'] & Volatile['resolve']>;
+    } : 'scoped' extends Type ? {
+        derive: Ephemeral['derive'] & Partial<Volatile['derive']>;
+        resolve: Ephemeral['resolve'] & Partial<Volatile['resolve']>;
+    } : {
+        derive: Ephemeral['derive'] & Volatile['derive'];
+        resolve: Ephemeral['resolve'] & Volatile['resolve'];
+    }), BasePath>>) => MaybePromise<Derivative>): Type extends 'global' ? Elysia<BasePath, Scoped, {
+        decorator: Singleton['decorator'];
+        store: Singleton['store'];
+        derive: Singleton['resolve'];
+        resolve: Prettify<Singleton['resolve'] & ExcludeElysiaResponse<Derivative>>;
+    }, Definitions, Metadata, Routes, Ephemeral, Volatile> : Type extends 'scoped' ? Elysia<BasePath, Scoped, Singleton, Definitions, Metadata, Routes, {
+        derive: Ephemeral['resolve'];
+        resolve: Prettify<Ephemeral['resolve'] & ExcludeElysiaResponse<Derivative>>;
+        schema: Ephemeral['schema'];
+    }, Volatile> : Elysia<BasePath, Scoped, Singleton, Definitions, Metadata, Routes, Ephemeral, {
+        derive: Volatile['resolve'];
+        resolve: Prettify<Volatile['resolve'] & ExcludeElysiaResponse<Derivative>>;
+        schema: Volatile['schema'];
+    }>;
+    model<const Name extends string, const Model extends TSchema>(name: Name, model: Model): Elysia<BasePath, Scoped, Singleton, {
+        type: Prettify<Definitions['type'] & {
+            [name in Name]: Static<Model>;
+        }>;
+        error: Definitions['error'];
+    }, Metadata, Routes, Ephemeral, Volatile>;
+    model<const Recorder extends Record<string, TSchema>>(record: Recorder): Elysia<BasePath, Scoped, Singleton, {
+        type: Prettify<Definitions['type'] & {
+            [key in keyof Recorder]: Static<Recorder[key]>;
+        }>;
+        error: Definitions['error'];
+    }, Metadata, Routes, Ephemeral, Volatile>;
+    model<const NewType extends Record<string, TSchema>>(mapper: (decorators: {
+        [type in keyof Definitions['type']]: ReturnType<typeof t.Unsafe<Definitions['type'][type]>>;
+    }) => NewType): Elysia<BasePath, Scoped, Singleton, {
+        type: {
+            [x in keyof NewType]: Static<NewType[x]>;
+        };
+        error: Definitions['error'];
+    }, Metadata, Routes, Ephemeral, Volatile>;
+    mapDerive<const NewDerivative extends Record<string, unknown>>(mapper: (context: Context<Metadata['schema'] & Ephemeral['schema'] & Volatile['schema'], Singleton & {
+        derive: Ephemeral['derive'] & Volatile['derive'];
+        resolve: Ephemeral['resolve'] & Volatile['resolve'];
+    }, BasePath>) => MaybePromise<NewDerivative>): Elysia<BasePath, Scoped, Singleton, Definitions, Metadata, Routes, Ephemeral, {
+        derive: NewDerivative;
+        resolve: Volatile['resolve'];
+        schema: Volatile['schema'];
+    }>;
+    mapDerive<const NewDerivative extends Record<string, unknown>, const Type extends LifeCycleType>(options: {
+        as?: Type;
+    }, mapper: (context: Context<Metadata['schema'] & Ephemeral['schema'] & Volatile['schema'], Singleton & ('global' extends Type ? {
+        derive: Partial<Ephemeral['derive'] & Volatile['derive']>;
+        resolve: Partial<Ephemeral['resolve'] & Volatile['resolve']>;
+    } : 'scoped' extends Type ? {
+        derive: Ephemeral['derive'] & Partial<Volatile['derive']>;
+        resolve: Ephemeral['resolve'] & Partial<Volatile['resolve']>;
+    } : {
+        derive: Ephemeral['derive'] & Volatile['derive'];
+        resolve: Ephemeral['resolve'] & Volatile['resolve'];
+    }), BasePath>) => MaybePromise<NewDerivative>): Type extends 'global' ? Elysia<BasePath, Scoped, {
+        decorator: Singleton['decorator'];
+        store: Singleton['store'];
+        derive: Singleton['resolve'];
+        resolve: Prettify<Singleton['resolve'] & ExcludeElysiaResponse<NewDerivative>>;
+    }, Definitions, Metadata, Routes, Ephemeral, Volatile> : Type extends 'scoped' ? Elysia<BasePath, Scoped, Singleton, Definitions, Metadata, Routes, {
+        derive: Ephemeral['resolve'];
+        resolve: Prettify<Ephemeral['resolve'] & ExcludeElysiaResponse<NewDerivative>>;
+        schema: Ephemeral['schema'];
+    }, Volatile> : Elysia<BasePath, Scoped, Singleton, Definitions, Metadata, Routes, Ephemeral, {
+        derive: Volatile['resolve'];
+        resolve: Prettify<Volatile['resolve'] & ExcludeElysiaResponse<NewDerivative>>;
+        schema: Volatile['schema'];
+    }>;
+    affix<const Base extends 'prefix' | 'suffix', const Type extends 'all' | 'decorator' | 'state' | 'model' | 'error', const Word extends string>(base: Base, type: Type, word: Word): Elysia<BasePath, Scoped, {
+        decorator: Type extends 'decorator' | 'all' ? 'prefix' extends Base ? Word extends `${string}${'_' | '-' | ' '}` ? AddPrefix<Word, Singleton['decorator']> : AddPrefixCapitalize<Word, Singleton['decorator']> : AddSuffixCapitalize<Word, Singleton['decorator']> : Singleton['decorator'];
+        store: Type extends 'state' | 'all' ? 'prefix' extends Base ? Word extends `${string}${'_' | '-' | ' '}` ? AddPrefix<Word, Singleton['store']> : AddPrefixCapitalize<Word, Singleton['store']> : AddSuffix<Word, Singleton['store']> : Singleton['store'];
+        derive: Type extends 'decorator' | 'all' ? 'prefix' extends Base ? Word extends `${string}${'_' | '-' | ' '}` ? AddPrefix<Word, Singleton['derive']> : AddPrefixCapitalize<Word, Singleton['derive']> : AddSuffixCapitalize<Word, Singleton['derive']> : Singleton['derive'];
+        resolve: Type extends 'decorator' | 'all' ? 'prefix' extends Base ? Word extends `${string}${'_' | '-' | ' '}` ? AddPrefix<Word, Singleton['resolve']> : AddPrefixCapitalize<Word, Singleton['resolve']> : AddSuffixCapitalize<Word, Singleton['resolve']> : Singleton['resolve'];
+    }, {
+        type: Type extends 'model' | 'all' ? 'prefix' extends Base ? Word extends `${string}${'_' | '-' | ' '}` ? AddPrefix<Word, Definitions['type']> : AddPrefixCapitalize<Word, Definitions['type']> : AddSuffixCapitalize<Word, Definitions['type']> : Definitions['type'];
+        error: Type extends 'error' | 'all' ? 'prefix' extends Base ? Word extends `${string}${'_' | '-' | ' '}` ? AddPrefix<Word, Definitions['error']> : AddPrefixCapitalize<Word, Definitions['error']> : AddSuffixCapitalize<Word, Definitions['error']> : Definitions['error'];
+    }, Metadata, Routes, Ephemeral, Volatile>;
+    prefix<const Type extends 'all' | 'decorator' | 'state' | 'model' | 'error', const Word extends string>(type: Type, word: Word): Elysia<BasePath, Scoped, {
+        decorator: Type extends "decorator" | "all" ? Word extends `${string} ` | `${string}_` | `${string}-` ? AddPrefix<Word, Singleton["decorator"]> : AddPrefixCapitalize<Word, Singleton["decorator"]> : Singleton["decorator"];
+        store: Type extends "all" | "state" ? Word extends `${string} ` | `${string}_` | `${string}-` ? AddPrefix<Word, Singleton["store"]> : AddPrefixCapitalize<Word, Singleton["store"]> : Singleton["store"];
+        derive: Type extends "decorator" | "all" ? Word extends `${string} ` | `${string}_` | `${string}-` ? AddPrefix<Word, Singleton["derive"]> : AddPrefixCapitalize<Word, Singleton["derive"]> : Singleton["derive"];
+        resolve: Type extends "decorator" | "all" ? Word extends `${string} ` | `${string}_` | `${string}-` ? AddPrefix<Word, Singleton["resolve"]> : AddPrefixCapitalize<Word, Singleton["resolve"]> : Singleton["resolve"];
+    }, {
+        type: Type extends "all" | "model" ? Word extends `${string} ` | `${string}_` | `${string}-` ? AddPrefix<Word, Definitions["type"]> : AddPrefixCapitalize<Word, Definitions["type"]> : Definitions["type"];
+        error: Type extends "error" | "all" ? Word extends `${string} ` | `${string}_` | `${string}-` ? AddPrefix<Word, Definitions["error"]> : AddPrefixCapitalize<Word, Definitions["error"]> : Definitions["error"];
+    }, Metadata, Routes, Ephemeral, Volatile>;
+    suffix<const Type extends 'all' | 'decorator' | 'state' | 'model' | 'error', const Word extends string>(type: Type, word: Word): Elysia<BasePath, Scoped, {
+        decorator: Type extends "decorator" | "all" ? AddSuffixCapitalize<Word, Singleton["decorator"]> : Singleton["decorator"];
+        store: Type extends "all" | "state" ? AddSuffix<Word, Singleton["store"]> : Singleton["store"];
+        derive: Type extends "decorator" | "all" ? AddSuffixCapitalize<Word, Singleton["derive"]> : Singleton["derive"];
+        resolve: Type extends "decorator" | "all" ? AddSuffixCapitalize<Word, Singleton["resolve"]> : Singleton["resolve"];
+    }, {
+        type: Type extends "all" | "model" ? AddSuffixCapitalize<Word, Definitions["type"]> : Definitions["type"];
+        error: Type extends "error" | "all" ? AddSuffixCapitalize<Word, Definitions["error"]> : Definitions["error"];
+    }, Metadata, Routes, Ephemeral, Volatile>;
+    compile(): this;
+    handle: (request: Request) => Promise<Response>;
+    /**
+     * Use handle can be either sync or async to save performance.
+     *
+     * Beside benchmark purpose, please use 'handle' instead.
+     */
+    fetch: (request: Request) => MaybePromise<Response>;
+    private handleError;
+    private outerErrorHandler;
+    /**
+     * ### listen
+     * Assign current instance to port and start serving
+     *
+     * ---
+     * @example
+     * ```typescript
+     * new Elysia()
+     *     .get("/", () => 'hi')
+     *     .listen(8080)
+     * ```
+     */
+    listen: (options: string | number | Partial<Serve>, callback?: ListenCallback) => this;
+    /**
+     * ### stop
+     * Stop server from serving
+     *
+     * ---
+     * @example
+     * ```typescript
+     * const app = new Elysia()
+     *     .get("/", () => 'hi')
+     *     .listen(8080)
+     *
+     * // Sometime later
+     * app.stop()
+     * ```
+     */
+    stop: () => Promise<void>;
+    /**
+     * Wait until all lazy loaded modules all load is fully
+     */
+    get modules(): Promise<any[]>;
+}
+export { Elysia };
+export { mapResponse, mapCompactResponse, mapEarlyResponse } from './handler';
+export { t } from './type-system';
+export { Cookie, type CookieOptions } from './cookies';
+export { getSchemaValidator, mergeHook, mergeObjectArray, getResponseSchemaValidator, StatusMap, InvertedStatusMap } from './utils';
+export { error, ParseError, NotFoundError, ValidationError, InternalServerError, InvalidCookieSignature, ERROR_CODE, ELYSIA_RESPONSE } from './error';
+export type { Context, PreContext } from './context';
+export type { ElysiaFn, EphemeralType, CreateEden, ComposeElysiaResponse, ElysiaConfig, SingletonBase, DefinitionBase, RouteBase, Handler, ComposedHandler, InputSchema, LocalHook, MergeSchema, RouteSchema, UnwrapRoute, InternalRoute, HTTPMethod, SchemaValidator, VoidHandler, PreHandler, BodyHandler, OptionalHandler, ErrorHandler, AfterHandler, LifeCycleEvent, TraceEvent, LifeCycleStore, LifeCycleType, MaybePromise, ListenCallback, UnwrapSchema, TraceHandler, TraceProcess, TraceReporter, TraceStream, Checksum } from './types';
+export type { Static, TSchema } from '@sinclair/typebox';