elysia
Version:
Ergonomic Framework for Human
1,063 lines • 92.7 kB
TypeScript
import { Memoirist } from 'memoirist';
import { type TObject, type Static, type TSchema, type TModule, type TRef, type TProperties } from '@sinclair/typebox';
import type { Context } from './context';
import { type Sucrose } from './sucrose';
import type { WSLocalHook } from './ws/types';
import type { ElysiaAdapter } from './adapter/types';
import type { ListenCallback, Serve, Server } from './universal/server';
import { PromiseGroup } from './utils';
import { type DynamicHandler } from './dynamic-handle';
import { ValidationError, type ParseError, type NotFoundError, type InternalServerError, ElysiaCustomStatusResponse } from './error';
import type { TraceHandler } from './trace';
import type { ElysiaConfig, SingletonBase, DefinitionBase, ComposedHandler, InputSchema, LocalHook, MergeSchema, RouteSchema, UnwrapRoute, InternalRoute, HTTPMethod, PreHandler, BodyHandler, OptionalHandler, ErrorHandler, LifeCycleStore, MaybePromise, Prettify, Prettify2, AddPrefix, AddSuffix, AddPrefixCapitalize, AddSuffixCapitalize, MaybeArray, GracefulHandler, MapResponse, MacroManager, MacroToProperty, TransformHandler, MetadataBase, RouteBase, CreateEden, ComposeElysiaResponse, InlineHandler, HookContainer, LifeCycleType, MacroQueue, EphemeralType, ExcludeElysiaResponse, ModelValidator, BaseMacroFn, ContextAppendType, Reconcile, AfterResponseHandler, HigherOrderFunction, ResolvePath, JoinPath, ValidatorLayer, MergeElysiaInstances, HookMacroFn, ResolveHandler, ResolveResolutions, MacroToContext, StandaloneValidator, GuardSchemaType, Or, PrettifySchema, IsNever, DocumentDecoration, AfterHandler } from './types';
export type AnyElysia = Elysia<any, any, any, any, any, any, any>;
/**
* ### Elysia Server
* Main instance to create web server using Elysia
*
* ---
* @example
* ```typescript
* import { Elysia } from 'elysia'
*
* new Elysia()
* .get("/", () => "Hello")
* .listen(3000)
* ```
*/
export default class Elysia<const in out BasePath extends string = '', const in out Singleton extends SingletonBase = {
decorator: {};
store: {};
derive: {};
resolve: {};
}, const in out Definitions extends DefinitionBase = {
typebox: {};
error: {};
}, const in out Metadata extends MetadataBase = {
schema: {};
standaloneSchema: {};
macro: {};
macroFn: {};
parser: {};
}, const out Routes extends RouteBase = {}, const in out Ephemeral extends EphemeralType = {
derive: {};
resolve: {};
schema: {};
standaloneSchema: {};
}, const in out Volatile extends EphemeralType = {
derive: {};
resolve: {};
schema: {};
standaloneSchema: {};
}> {
config: ElysiaConfig<BasePath>;
server: Server | null;
private dependencies;
'~Prefix': BasePath;
'~Singleton': Singleton;
'~Definitions': Definitions;
'~Metadata': Metadata;
'~Ephemeral': Ephemeral;
'~Volatile': Volatile;
'~Routes': Routes;
protected singleton: SingletonBase;
get store(): Singleton['store'];
get decorator(): Singleton['decorator'];
protected definitions: {
typebox: TModule<{}, {}>;
type: Record<string, TSchema>;
error: Record<string, Error>;
};
protected extender: {
macros: MacroQueue[];
higherOrderFunctions: HookContainer<HigherOrderFunction>[];
};
protected validator: ValidatorLayer;
protected standaloneValidator: StandaloneValidator;
event: Partial<LifeCycleStore>;
protected telemetry: undefined | {
stack: string | undefined;
};
router: {
'~http': Memoirist<{
compile: Function;
handler?: ComposedHandler;
}> | undefined;
readonly http: Memoirist<{
compile: Function;
handler?: ComposedHandler;
}>;
'~dynamic': Memoirist<DynamicHandler> | undefined;
readonly dynamic: Memoirist<DynamicHandler>;
static: { [path in string]: { [method in string]: number; }; };
response: {
[path: string]: MaybePromise<Response | undefined> | {
[method: string]: MaybePromise<Response | undefined>;
};
};
history: InternalRoute[];
};
protected routeTree: Record<string, number>;
get routes(): InternalRoute[];
protected getGlobalRoutes(): InternalRoute[];
protected getGlobalDefinitions(): {
typebox: TModule<{}, {}>;
type: Record<string, TSchema>;
error: Record<string, Error>;
};
protected inference: Sucrose.Inference;
private getServer;
private getParent;
'~parser': {
[K in string]: BodyHandler<any, any>;
};
private _promisedModules;
private get promisedModules();
constructor(config?: ElysiaConfig<BasePath>);
'~adapter': ElysiaAdapter;
env(model: TObject<any>, _env?: NodeJS.ProcessEnv): this;
/**
* @private DO_NOT_USE_OR_YOU_WILL_BE_FIRED
* @version 1.1.0
*
* ! Do not use unless you know exactly what you are doing
* ? Add Higher order function to Elysia.fetch
*/
wrap(fn: HigherOrderFunction): this;
private applyMacro;
get models(): {
[K in keyof Definitions['typebox']]: ModelValidator<Definitions['typebox'][K]>;
} & {
modules: TModule<Definitions['typebox']>;
};
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(({ server }) => {
* console.log("Running at ${server?.url}:${server?.port}")
* })
* .listen(3000)
* ```
*/
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, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>> & Metadata['standaloneSchema'] & Ephemeral['standaloneSchema'] & Volatile['standaloneSchema'], {
decorator: Singleton['decorator'];
store: Singleton['store'];
derive: {};
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, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>, BasePath> & Metadata['standaloneSchema'] & Ephemeral['standaloneSchema'] & Volatile['standaloneSchema'], {
decorator: Singleton['decorator'];
store: Singleton['store'];
derive: Singleton['derive'] & Ephemeral['derive'] & Volatile['derive'];
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, const Type extends LifeCycleType>(options: {
as?: Type;
}, parser: MaybeArray<BodyHandler<MergeSchema<Schema, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>, BasePath> & Metadata['standaloneSchema'] & Ephemeral['standaloneSchema'] & Volatile['standaloneSchema'] & 'global' extends Type ? {
params: Record<string, string>;
} : 'scoped' extends Type ? {
params: Record<string, string>;
} : {}, 'global' extends Type ? {
decorator: Singleton['decorator'];
store: Singleton['store'];
derive: Singleton['derive'] & Partial<Ephemeral['derive'] & Volatile['derive']>;
resolve: {};
} : 'scoped' extends Type ? {
decorator: Singleton['decorator'];
store: Singleton['store'];
derive: Singleton['derive'] & Ephemeral['derive'] & Partial<Volatile['derive']>;
resolve: {};
} : {
decorator: Singleton['decorator'];
store: Singleton['store'];
derive: Singleton['derive'] & Ephemeral['derive'] & Volatile['derive'];
resolve: {};
}>>): this;
onParse<const Parsers extends keyof Metadata['parser']>(parser: Parsers): 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()
* })
* ```
*/
parser<const Parser extends string, const Schema extends RouteSchema, const Handler extends BodyHandler<MergeSchema<Schema, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>, BasePath> & Metadata['standaloneSchema'] & Ephemeral['standaloneSchema'] & Volatile['standaloneSchema'], {
decorator: Singleton['decorator'];
store: Singleton['store'];
derive: Singleton['derive'] & Ephemeral['derive'] & Volatile['derive'];
resolve: {};
}>>(name: Parser, parser: Handler): Elysia<BasePath, Singleton, Definitions, {
schema: Metadata['schema'];
standaloneSchema: Metadata['standaloneSchema'];
macro: Metadata['macro'];
macroFn: Metadata['macroFn'];
parser: Metadata['parser'] & {
[K in Parser]: Handler;
};
}, Routes, Ephemeral, Volatile>;
/**
* ### 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, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>, BasePath> & Metadata['standaloneSchema'] & Ephemeral['standaloneSchema'] & Volatile['standaloneSchema'], {
decorator: Singleton['decorator'];
store: Singleton['store'];
derive: Singleton['derive'] & Ephemeral['derive'] & Volatile['derive'];
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, const Type extends LifeCycleType>(options: {
as?: Type;
}, handler: MaybeArray<TransformHandler<MergeSchema<Schema, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>, BasePath> & Metadata['standaloneSchema'] & Ephemeral['standaloneSchema'] & Volatile['standaloneSchema'] & 'global' extends Type ? {
params: Record<string, string>;
} : 'scoped' extends Type ? {
params: Record<string, string>;
} : {}, 'global' extends Type ? {
decorator: Singleton['decorator'];
store: Singleton['store'];
derive: Singleton['derive'] & Ephemeral['derive'] & Volatile['derive'];
resolve: {};
} : 'scoped' extends Type ? {
decorator: Singleton['decorator'];
store: Singleton['store'];
derive: Singleton['derive'] & Ephemeral['derive'] & Partial<Volatile['derive']>;
resolve: {};
} : {
decorator: Singleton['decorator'];
store: Singleton['store'];
derive: Singleton['derive'] & Partial<Ephemeral['derive'] & Volatile['derive']>;
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> | ElysiaCustomStatusResponse<any, any, any>, const Type extends LifeCycleType>(options: {
as?: Type;
}, resolver: (context: Prettify<Context<MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>, BasePath> & Metadata['standaloneSchema'] & Ephemeral['standaloneSchema'] & Volatile['standaloneSchema'] & 'global' extends Type ? {
params: Record<string, string>;
} : 'scoped' extends Type ? {
params: Record<string, string>;
} : {}, 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 | void>): Type extends 'global' ? Elysia<BasePath, {
decorator: Singleton['decorator'];
store: Singleton['store'];
derive: Singleton['derive'];
resolve: Prettify<Singleton['resolve'] & ExcludeElysiaResponse<Resolver>>;
}, Definitions, Metadata, Routes, Ephemeral, Volatile> : Type extends 'scoped' ? Elysia<BasePath, Singleton, Definitions, Metadata, Routes, {
derive: Ephemeral['derive'];
resolve: Prettify<Ephemeral['resolve'] & ExcludeElysiaResponse<Resolver>>;
schema: Ephemeral['schema'];
standaloneSchema: Ephemeral['standaloneSchema'];
}, Volatile> : Elysia<BasePath, Singleton, Definitions, Metadata, Routes, Ephemeral, {
derive: Volatile['derive'];
resolve: Prettify<Volatile['resolve'] & ExcludeElysiaResponse<Resolver>>;
schema: Volatile['schema'];
standaloneSchema: Volatile['standaloneSchema'];
}>;
/**
* 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> | ElysiaCustomStatusResponse<any, any, any> | void>(resolver: (context: Prettify<Context<MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>, BasePath> & Metadata['standaloneSchema'] & Ephemeral['standaloneSchema'] & Volatile['standaloneSchema'], Singleton & {
derive: Ephemeral['derive'] & Volatile['derive'];
resolve: Ephemeral['resolve'] & Volatile['resolve'];
}, BasePath>>) => MaybePromise<Resolver | void>): Elysia<BasePath, Singleton, Definitions, Metadata, Routes, Ephemeral, {
derive: Volatile['derive'];
resolve: Prettify<Volatile['resolve'] & ExcludeElysiaResponse<Resolver>>;
schema: Volatile['schema'];
standaloneSchema: Volatile['standaloneSchema'];
}>;
mapResolve<const NewResolver extends Record<string, unknown> | ElysiaCustomStatusResponse<any, any, any>>(mapper: (context: Context<MergeSchema<Metadata['schema'], MergeSchema<Ephemeral['schema'], Volatile['schema']>> & Metadata['standaloneSchema'] & Ephemeral['standaloneSchema'] & Volatile['standaloneSchema'], Singleton & {
derive: Ephemeral['derive'] & Volatile['derive'];
resolve: Ephemeral['resolve'] & Volatile['resolve'];
}, BasePath>) => MaybePromise<NewResolver | void>): Elysia<BasePath, Singleton, Definitions, Metadata, Routes, Ephemeral, {
derive: Volatile['derive'];
resolve: ExcludeElysiaResponse<NewResolver>;
schema: Volatile['schema'];
standaloneSchema: Volatile['standaloneSchema'];
}>;
mapResolve<const NewResolver extends Record<string, unknown> | ElysiaCustomStatusResponse<any, any, any>, const Type extends LifeCycleType>(options: {
as?: Type;
}, mapper: (context: Context<MergeSchema<Metadata['schema'], MergeSchema<Ephemeral['schema'], Volatile['schema']>> & Metadata['standaloneSchema'] & Ephemeral['standaloneSchema'] & Volatile['standaloneSchema'], 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 | void>): Type extends 'global' ? Elysia<BasePath, {
decorator: Singleton['decorator'];
store: Singleton['store'];
derive: Singleton['derive'];
resolve: ExcludeElysiaResponse<NewResolver>;
}, Definitions, Metadata, Routes, Ephemeral, Volatile> : Type extends 'scoped' ? Elysia<BasePath, Singleton, Definitions, Metadata, Routes, {
derive: Ephemeral['derive'];
resolve: Prettify<Ephemeral['resolve'] & ExcludeElysiaResponse<NewResolver>>;
schema: Ephemeral['schema'];
standaloneSchema: Ephemeral['standaloneSchema'];
}, Volatile> : Elysia<BasePath, Singleton, Definitions, Metadata, Routes, Ephemeral, {
derive: Volatile['derive'];
resolve: Prettify<Volatile['resolve'] & ExcludeElysiaResponse<NewResolver>>;
schema: Volatile['schema'];
standaloneSchema: Volatile['standaloneSchema'];
}>;
/**
* ### 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, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>, BasePath> & Metadata['standaloneSchema'] & Ephemeral['standaloneSchema'] & Volatile['standaloneSchema'], 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, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>, BasePath> & Metadata['standaloneSchema'] & Ephemeral['standaloneSchema'] & Volatile['standaloneSchema'] & 'global' extends Type ? {
params: Record<string, string>;
} : 'scoped' extends Type ? {
params: Record<string, string>;
} : {}, 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, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>, BasePath> & Metadata['standaloneSchema'] & Ephemeral['standaloneSchema'] & Volatile['standaloneSchema'], Singleton & {
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)
* })
* ```
*/
onAfterHandle<const Schema extends RouteSchema, const Type extends LifeCycleType>(options: {
as?: LifeCycleType;
}, handler: MaybeArray<AfterHandler<MergeSchema<Schema, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>, BasePath> & Metadata['standaloneSchema'] & Ephemeral['standaloneSchema'] & Volatile['standaloneSchema'] & 'global' extends Type ? {
params: Record<string, string>;
} : 'scoped' extends Type ? {
params: Record<string, string>;
} : {}, 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, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>, BasePath> & Metadata['standaloneSchema'] & Ephemeral['standaloneSchema'] & Volatile['standaloneSchema'], Singleton & {
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, Type extends LifeCycleType>(options: {
as?: Type;
}, handler: MaybeArray<MapResponse<MergeSchema<Schema, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>, BasePath> & Metadata['standaloneSchema'] & Ephemeral['standaloneSchema'] & Volatile['standaloneSchema'] & 'global' extends Type ? {
params: Record<string, string>;
} : 'scoped' extends Type ? {
params: Record<string, string>;
} : {}, 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
* Call AFTER main handler is executed
* Good for analytic metrics
* ---
* @example
* ```typescript
* new Elysia()
* .onAfterResponse(() => {
* cleanup()
* })
* ```
*/
onAfterResponse<const Schema extends RouteSchema>(handler: MaybeArray<AfterResponseHandler<MergeSchema<Schema, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>, BasePath> & Metadata['standaloneSchema'] & Ephemeral['standaloneSchema'] & Volatile['standaloneSchema'], Singleton & {
derive: Ephemeral['derive'] & Volatile['derive'];
resolve: Ephemeral['resolve'] & Volatile['resolve'];
}>>): this;
/**
* ### response | Life cycle event
* Call AFTER main handler is executed
* Good for analytic metrics
*
* ---
* @example
* ```typescript
* new Elysia()
* .onAfterResponse(() => {
* cleanup()
* })
* ```
*/
onAfterResponse<const Schema extends RouteSchema, const Type extends LifeCycleType>(options: {
as?: Type;
}, handler: MaybeArray<AfterResponseHandler<MergeSchema<Schema, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>, BasePath> & Metadata['standaloneSchema'] & Ephemeral['standaloneSchema'] & Volatile['standaloneSchema'] & 'global' extends Type ? {
params: Record<string, string>;
} : 'scoped' extends Type ? {
params: Record<string, string>;
} : {}, 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, Singleton, {
typebox: Definitions['typebox'];
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, Singleton, {
typebox: Definitions['typebox'];
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, Singleton, {
typebox: Definitions['typebox'];
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: MaybeArray<ErrorHandler<Definitions['error'], MergeSchema<Schema, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>> & Metadata['standaloneSchema'] & Ephemeral['standaloneSchema'] & Volatile['standaloneSchema'], Singleton, Ephemeral, Volatile>>): 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, const Scope extends LifeCycleType>(options: {
as?: Scope;
}, handler: MaybeArray<ErrorHandler<Definitions['error'], MergeSchema<Schema, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>> & Metadata['standaloneSchema'] & Ephemeral['standaloneSchema'] & Volatile['standaloneSchema'], Scope extends 'global' ? {
store: Singleton['store'];
decorator: Singleton['decorator'];
derive: Singleton['derive'] & Ephemeral['derive'] & Volatile['derive'];
resolve: Singleton['resolve'] & Ephemeral['resolve'] & Volatile['resolve'];
} : Scope extends 'scoped' ? {
store: Singleton['store'];
decorator: Singleton['decorator'];
derive: Singleton['derive'] & Ephemeral['derive'];
resolve: Singleton['resolve'] & Ephemeral['resolve'];
} : Singleton, Scope extends 'global' ? Ephemeral : {
derive: Partial<Ephemeral['derive']>;
resolve: Partial<Ephemeral['resolve']>;
schema: Ephemeral['schema'];
standaloneSchema: Ephemeral['standaloneSchema'];
}, Scope extends 'global' ? Ephemeral : Scope extends 'scoped' ? Ephemeral : {
derive: Partial<Ephemeral['derive']>;
resolve: Partial<Ephemeral['resolve']>;
schema: Ephemeral['schema'];
standaloneSchema: Ephemeral['standaloneSchema'];
}>>): 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: Event, handlers: MaybeArray<Extract<LifeCycleStore[Event], HookContainer[]>[0]['fn']>): 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: Event, handlers: MaybeArray<Extract<LifeCycleStore[Event], Function[]>[0]>): this;
as(type: 'global'): Elysia<BasePath, {
decorator: Singleton['decorator'];
store: Singleton['store'];
derive: Prettify<Singleton['derive'] & Ephemeral['derive'] & Volatile['derive']>;
resolve: Prettify<Singleton['resolve'] & Ephemeral['resolve'] & Volatile['resolve']>;
}, Definitions, {
schema: MergeSchema<MergeSchema<Volatile['schema'], Ephemeral['schema']>, Metadata['schema']>;
standaloneSchema: Metadata['standaloneSchema'];
macro: Metadata['macro'];
macroFn: Metadata['macroFn'];
parser: Metadata['parser'];
}, Routes, {
derive: {};
resolve: {};
schema: {};
standaloneSchema: {};
}, {
derive: {};
resolve: {};
schema: {};
standaloneSchema: {};
}>;
as(type: 'scoped'): Elysia<BasePath, Singleton, Definitions, Metadata, Routes, {
derive: Prettify<Ephemeral['derive'] & Volatile['derive']>;
resolve: Prettify<Ephemeral['resolve'] & Volatile['resolve']>;
schema: MergeSchema<Volatile['schema'], Ephemeral['schema']>;
standaloneSchema: PrettifySchema<Volatile['standaloneSchema'] & Ephemeral['standaloneSchema']>;
}, {
derive: {};
resolve: {};
schema: {};
standaloneSchema: {};
}>;
group<const Prefix extends string, const NewElysia extends AnyElysia>(prefix: Prefix, run: (group: Elysia<JoinPath<BasePath, Prefix>, Singleton, Definitions, {
schema: MergeSchema<UnwrapRoute<{}, Definitions['typebox'], JoinPath<BasePath, Prefix>>, Metadata['schema']>;
standaloneSchema: Prettify<UnwrapRoute<{}, Definitions['typebox'], JoinPath<BasePath, Prefix>> & Metadata['standaloneSchema']>;
macro: Metadata['macro'];
macroFn: Metadata['macroFn'];
parser: Metadata['parser'];
}, {}, Ephemeral, Volatile>) => NewElysia): Elysia<BasePath, Singleton, Definitions, Metadata, Prettify<Routes & NewElysia['~Routes']>, Ephemeral, Volatile>;
group<const Prefix extends string, const NewElysia extends AnyElysia, const Input extends InputSchema<keyof Definitions['typebox'] & string>, const Schema extends MergeSchema<UnwrapRoute<Input, Definitions['typebox'], JoinPath<BasePath, Prefix>>, Metadata['schema']> & Metadata['standaloneSchema'], const Resolutions extends MaybeArray<ResolveHandler<Schema, Singleton & {
derive: Ephemeral['derive'] & Volatile['derive'];
resolve: Ephemeral['resolve'] & Volatile['resolve'];
}>>>(prefix: Prefix, schema: LocalHook<Input, Schema, Singleton & {
derive: Ephemeral['derive'] & Volatile['derive'];
resolve: Ephemeral['resolve'] & Volatile['resolve'];
}, Definitions['error'], Metadata['macro'], keyof Metadata['parser']>, run: (group: Elysia<JoinPath<BasePath, Prefix>, {
decorator: Singleton['decorator'];
store: Singleton['store'];
derive: Prettify<Singleton['derive'] & Ephemeral['derive'] & Volatile['derive']>;
resolve: Prettify<Singleton['resolve'] & Ephemeral['resolve'] & Volatile['resolve'] & ResolveResolutions<Resolutions>>;
}, Definitions, {
schema: Prettify<Schema>;
standaloneSchema: Metadata['standaloneSchema'];
macro: Metadata['macro'];
macroFn: Metadata['macroFn'];
parser: Metadata['parser'];
}, {}, Ephemeral, Volatile>) => NewElysia): Elysia<BasePath, Singleton, Definitions, Metadata, Routes & NewElysia['~Routes'], Ephemeral, Volatile>;
guard<const LocalSchema extends InputSchema<keyof Definitions['typebox'] & string>, const Schema extends MergeSchema<UnwrapRoute<LocalSchema, Definitions['typebox'], BasePath>, Metadata['schema']>, const Macro extends Metadata['macro'], const MacroContext extends MacroToContext<Metadata['macroFn'], NoInfer<Macro>>, const GuardType extends GuardSchemaType, const AsType extends LifeCycleType>(hook: {
/**
* @default 'override'
*/
as?: AsType;
/**
* @default 'standalone'
* @since 1.3.0
*/
schema?: GuardType;
} & LocalHook<LocalSchema, Schema, Singleton & {
derive: Ephemeral['derive'] & Volatile['derive'];
resolve: Ephemeral['resolve'] & Volatile['resolve'];
}, Definitions['error'], Macro, keyof Metadata['parser']>): Or<GuardSchemaType extends GuardType ? true : false, GuardType extends 'override' ? true : false> extends true ? Or<LifeCycleType extends AsType ? true : false, AsType extends 'local' ? true : false> extends true ? Elysia<BasePath, Singleton, Definitions, Metadata, Routes, Ephemeral, {
derive: Volatile['derive'];
resolve: Prettify<Volatile['resolve'] & MacroContext>;
schema: Prettify<MergeSchema<UnwrapRoute<LocalSchema, Definitions['typebox']>, Metadata['schema']>>;
standaloneSchema: Volatile['standaloneSchema'];
}> : AsType extends 'global' ? Elysia<BasePath, {
decorator: Singleton['decorator'];
store: Singleton['store'];
derive: Singleton['derive'];
resolve: Prettify<Singleton['resolve'] & MacroContext>;
}, Definitions, {
schema: Prettify<MergeSchema<UnwrapRoute<LocalSchema, Definitions['typebox'], BasePath>, Metadata['schema']>>;
standaloneSchema: Metadata['standaloneSchema'];
macro: Metadata['macro'];
macroFn: Metadata['macroFn'];
parser: Metadata['parser'];
}, Routes, Ephemeral, Volatile> : Elysia<BasePath, Singleton, Definitions, Metadata, Routes, {
derive: Ephemeral['derive'];
resolve: Prettify<Ephemeral['resolve'] & MacroContext>;
schema: Prettify<MergeSchema<UnwrapRoute<LocalSchema, Definitions['typebox']>, Metadata['schema'] & Ephemeral['schema']>>;
standaloneSchema: Ephemeral['standaloneSchema'];
}, Volatile> : Or<LifeCycleType extends AsType ? true : false, AsType extends 'local' ? true : false> extends true ? Elysia<BasePath, Singleton, Definitions, Metadata, Routes, Ephemeral, {
derive: Volatile['derive'];
resolve: Prettify<Volatile['resolve'] & MacroContext>;
schema: Volatile['schema'];
standaloneSchema: Volatile['standaloneSchema'] & UnwrapRoute<LocalSchema, Definitions['typebox']>;
}> : AsType extends 'global' ? Elysia<BasePath, {
decorator: Singleton['decorator'];
store: Singleton['store'];
derive: Singleton['derive'];
resolve: Prettify<Singleton['resolve'] & MacroContext>;
}, Definitions, {
schema: Metadata['schema'];
standaloneSchema: UnwrapRoute<LocalSchema, Definitions['typebox'], BasePath> & Metadata['standaloneSchema'];
macro: Metadata['macro'];
macroFn: Metadata['macroFn'];
parser: Metadata['parser'];
}, Routes, Ephemeral, Volatile> : Elysia<BasePath, Singleton, Definitions, Metadata, Routes, {
derive: Ephemeral['derive'];
resolve: Prettify<Ephemeral['resolve'] & MacroContext>;
schema: Ephemeral['schema'];
standaloneSchema: Ephemeral['standaloneSchema'] & UnwrapRoute<LocalSchema, Definitions['typebox']>;
}, Volatile>;
guard<const LocalSchema extends InputSchema<keyof Definitions['typebox'] & string>, const Schema extends MergeSchema<UnwrapRoute<LocalSchema, Definitions['typebox'], BasePath>, Metadata['schema']>, const Macro extends Metadata['macro'], const MacroContext extends MacroToContext<Metadata['macroFn'], NoInfer<Macro>>>(hook: LocalHook<LocalSchema, Schema, Singleton & {
derive: Ephemeral['derive'] & Volatile['derive'];
resolve: Ephemeral['resolve'] & Volatile['resolve'] & MacroContext;
}, Definitions['error'], Macro, keyof Metadata['parser']>): Elysia<BasePath, Singleton, Definitions, Metadata, Routes, Ephemeral, {
derive: Volatile['derive'];
resolve: Prettify<Volatile['resolve'] & MacroContext>;
schema: Prettify<MergeSchema<UnwrapRoute<LocalSchema, Definitions['typebox'], BasePath>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>>>;
standaloneSchema: Metadata['standaloneSchema'];
}>;
guard<const LocalSchema extends InputSchema<keyof Definitions['typebox'] & string>, const NewElysia extends AnyElysia, const Schema extends MergeSchema<UnwrapRoute<LocalSchema, Definitions['typebox'], BasePath>, Metadata['schema']>, const Macro extends Metadata['macro'], const MacroContext extends MacroToContext<Metadata['macroFn'], NoInfer<Macro>>>(run: (group: Elysia<BasePath, {
decorator: Singleton['decorator'];
store: Singleton['store'];
derive: Singleton['derive'];
resolve: Singleton['resolve'] & MacroContext;
}, Definitions, {
schema: Prettify<Schema>;
standaloneSchema: Metadata['standaloneSchema'];
macro: Metadata['macro'];
macroFn: Metadata['macroFn'];
parser: Metadata['parser'];
}, {}, Ephemeral, Volatile>) => NewElysia): Elysia<BasePath, Singleton, Definitions, Metadata, Prettify<Routes & NewElysia['~Routes']>, Ephemeral, Volatile>;
guard<const LocalSchema extends InputSchema<keyof Definitions['typebox'] & string>, const NewElysia extends AnyElysia, const Schema extends MergeSchema<UnwrapRoute<LocalSchema, Definitions['typebox'], BasePath>, Metadata['schema']>, const Macro extends Metadata['macro'], const MacroContext extends MacroToContext<Metadata['macroFn'], NoInfer<Macro>>>(schema: LocalHook<LocalSchema, Schema, Singleton & {
derive: Ephemeral['derive'] & Volatile['derive'];
resolve: Ephemeral['resolve'] & Volatile['resolve'];
}, Definitions['error'], Macro, keyof Metadata['parser']>, run: (group: Elysia<BasePath, {
decorator: Singleton['decorator'];
store: Singleton['store'];
derive: Singleton['derive'];
resolve: Prettify<Singleton['resolve'] & MacroContext>;
}, Definitions, {
schema: Prettify<Schema>;
standaloneSchema: Metadata['standaloneSchema'];
macro: Metadata['macro'];
macroFn: Metadata['macroFn'];
parser: Metadata['parser'];
}, {}, Ephemeral, Volatile>) => NewElysia): Elysia<BasePath, Singleton, Definitions, Metadata, Prettify<Routes & NewElysia['~Routes']>, Ephemeral, {
derive: Volatile['derive'];
resolve: Prettify<Volatile['resolve'] & MacroContext>;
schema: Volatile['schema'];
standaloneSchema: Volatile['standaloneSchema'];
}>;
/**
* Inline fn
*/
use<const NewElysia extends AnyElysia, const Param extends AnyElysia = this>(plugin: (app: Param) => NewElysia): Elysia<BasePath, Prettify2<Singleton & NewElysia['~Singleton']>, Prettify<Definitions & NewElysia['~Definitions']>, Prettify2<Metadata & NewElysia['~Metadata']>, BasePath extends `` ? Routes & NewElysia['~Routes'] : Routes & CreateEden<BasePath, NewElysia['~Routes']>, Prettify2<Ephemeral & NewElysia['~Ephemeral']>, Prettify2<Volatile & NewElysia['~Volatile']>>;
/**
* Inline async fn
*/
use<const NewElysia extends AnyElysia, const Param extends AnyElysia = this>(plugin: ((app: Param) => Promise<NewElysia>) | Promise<(app: Param) => NewElysia>): Elysia<BasePath, {
decorator: Prettify<Singleton['decorator'] & Partial<NewElysia['~Singleton']['decorator']>>;
store: Prettify<Singleton['store'] & Partial<NewElysia['~Singleton']['store']>>;
derive: Prettify<Singleton['derive'] & Partial<NewElysia['~Singleton']['derive']>>;
resolve: Prettify<Singleton['resolve'] & Partial<NewElysia['~Singleton']['resolve']>>;
}, {
error: Prettify<Definitions['error'] & NewElysia['~Definitions']['error']>;
typebox: Prettify<Definitions['typebox'] & NewElysia['~Definitions']['typebox']>;
}, Prettify2<Metadata & NewElysia['~Metadata']>, BasePath extends `` ? Routes & NewElysia['~Routes'] : Routes & CreateEden<BasePath, NewElysia['~Routes']>, {
schema: Prettify<Ephemeral['schema'] & Partial<NewElysia['~Ephemeral']['schema']>>;
standaloneSchema: PrettifySchema<Ephemeral['standaloneSchema'] & Partial<NewElysia['~Ephemeral']['standaloneSchema']>>;
resolve: Prettify<Ephemeral['resolve'] & Partial<NewElysia['~Ephemeral']['resolve']>>;
derive: Prettify<Ephemeral['derive'] & Partial<NewElysia['~Ephemeral']['derive']>>;
}, {
schema: Prettify<Volatile['schema'] & Partial<NewElysia['~Volatile']['schema']>>;
standaloneSchema: PrettifySchema<Volatile['standaloneSchema'] & Partial<NewElysia['~Volatile']['standaloneSchema']>>;
resolve: Prettify<Volatile['resolve'] & Partial<NewElysia['~Volatile']['resolve']>>;
derive: Prettify<Volatile['derive'] & Partial<NewElysia['~Volatile']['derive']>>;
}>;
/**
* Entire Instance
**/
use<const NewElysia extends AnyElysia>(instance: MaybePromise<NewElysia>): Elysia<BasePath, Prettify2<Singleton & NewElysia['~Singleton']>, Prettify2<Definitions & NewElysia['~Definitions']>, Prettify2<Metadata & NewElysia['~Metadata']>, BasePath extends `` ? Routes & NewElysia['~Routes'] : Routes & CreateEden<BasePath, NewElysia['~Routes']>, Ephemeral, Prettify2<Volatile & NewElysia['~Ephemeral']>>;
/**
* Entire multiple Instance
**/
use<const Instances extends AnyElysia[]>(instance: MaybePromise<Instances>): MergeElysiaInstances<Instances, BasePath>;
/**
* Import fn
*/
use<const NewElysia extends AnyElysia>(plugin: Promise<{
default: (elysia: AnyElysia) => MaybePromise<NewElysia>;
}>): Elysia<BasePath, Prettify2<Singleton & NewElysia['~Singleton']>, {
error: Prettify<Definitions['error'] & NewElysia['~Definitions']['error']>;
typebox: Prettify<Definitions['typebox'] & NewElysia['~Definitions']['typebox']>;
}, Prettify2<Metadata & NewElysia['~Metadata']>, BasePath extends `` ? Routes & NewElysia['~Routes'] : Routes & CreateEden<BasePath, NewElysia['~Routes']>, Prettify2<Ephemeral & NewElysia['~Ephemeral']>, Prettify2<Volatile & NewElysia['~Volatile']>>;
/**
* Import entire instance
*/
use<const LazyLoadElysia extends AnyElysia>(plugin: Promise<{
default: LazyLoadElysia;
}>): Elysia<BasePath, {
decorator: Prettify<Singleton['decorator'] & Partial<LazyLoadElysia['~Singleton']['decorator']>>;
store: Prettify<Singleton['store'] & Partial<LazyLoadElysia['~Singleton']['store']>>;
derive: Prettify<S