elysia 0.6.2 → 0.6.4

package/dist/bun/index.d.ts

@@ -2,9 +2,15 @@
 import type { Serve, Server } from 'bun';
 import type { Context } from './context';
 import type { ElysiaWSOptions, WSTypedSchema } from './ws';
-import type { Handler, VoidRequestHandler, TypedRoute, ElysiaInstance, ElysiaConfig, HTTPMethod, InternalRoute, BodyParser, ErrorHandler, TypedSchema, LocalHook, LocalHandler, LifeCycle, LifeCycleEvent, LifeCycleStore, VoidLifeCycle, AfterRequestHandler, IsAny, OverwritableTypeRoute, MergeSchema, ListenCallback, NoReturnHandler, MaybePromise, Prettify, TypedWSRouteToEden, UnwrapSchema, ExtractPath, TypedSchemaToRoute, DeepWritable, Reconciliation, BeforeRequestHandler } from './types';
+import type { Handler, VoidRequestHandler, TypedRoute, ElysiaInstance, ElysiaConfig, HTTPMethod, InternalRoute, BodyParser, ErrorHandler, TypedSchema, LocalHook, LocalHandler, LifeCycle, LifeCycleEvent, LifeCycleStore, VoidLifeCycle, AfterRequestHandler, IsAny, OverwritableTypeRoute, MergeSchema, ListenCallback, NoReturnHandler, MaybePromise, Prettify, TypedWSRouteToEden, UnwrapSchema, ExtractPath, TypedSchemaToRoute, DeepWritable, Reconciliation, BeforeRequestHandler, ElysiaDefaultMeta } from './types';
 import type { Static, TSchema } from '@sinclair/typebox';
-export default class Elysia<Instance extends ElysiaInstance = {
+export default class Elysia<BasePath extends string = '', Instance extends ElysiaInstance<{
+    store?: Record<string, unknown>;
+    request?: Record<string, unknown>;
+    error?: Record<string, Error>;
+    schema?: TypedSchema<any>;
+    meta?: ElysiaDefaultMeta;
+}> = {
     path: '';
     store: {};
     request: {};
@@ -16,7 +22,7 @@ export default class Elysia<Instance extends ElysiaInstance = {
         exposed: {};
     };
 }> {
-    config: ElysiaConfig;
+    config: ElysiaConfig<BasePath>;
     private dependencies;
     store: Instance['store'];
     meta: Instance['meta'];
@@ -31,8 +37,8 @@ export default class Elysia<Instance extends ElysiaInstance = {
     private wsRouter;
     private dynamicRouter;
     private lazyLoadModules;
-    path: Instance['path'];
-    constructor(config?: Partial<ElysiaConfig>);
+    path: BasePath;
+    constructor(config?: Partial<ElysiaConfig<BasePath>>);
     private add;
     onStart(handler: VoidLifeCycle<Instance>): this;
     onRequest<Route extends OverwritableTypeRoute = TypedRoute>(handler: BeforeRequestHandler<Route, Instance>): this;
@@ -43,8 +49,7 @@ export default class Elysia<Instance extends ElysiaInstance = {
     onResponse<Route extends OverwritableTypeRoute = TypedRoute>(handler: VoidRequestHandler<Route, Instance>): this;
     addError<const Errors extends Record<string, {
         prototype: Error;
-    }>>(errors: Errors): Elysia<{
-        path: Instance['path'];
+    }>>(errors: Errors): Elysia<BasePath, {
         store: Instance['store'];
         error: Instance['error'] & {
             [K in NonNullable<keyof Errors>]: Errors[K] extends {
@@ -57,8 +62,7 @@ export default class Elysia<Instance extends ElysiaInstance = {
     }>;
     addError<Name extends string, const CustomError extends {
         prototype: Error;
-    }>(name: Name, errors: CustomError): Elysia<{
-        path: Instance['path'];
+    }>(name: Name, errors: CustomError): Elysia<BasePath, {
         store: Instance['store'];
         error: Instance['error'] & {
             [name in Name]: CustomError extends {
@@ -69,8 +73,7 @@ export default class Elysia<Instance extends ElysiaInstance = {
         schema: Instance['schema'];
         meta: Instance['meta'];
     }>;
-    onError(handler?: ErrorHandler<Instance['error']>): Elysia<{
-        path: Instance['path'];
+    onError(handler?: ErrorHandler<Instance['error']>): Elysia<BasePath, {
         store: Instance['store'];
         error: Instance['error'];
         request: Instance['request'];
@@ -79,8 +82,7 @@ export default class Elysia<Instance extends ElysiaInstance = {
     }>;
     onStop(handler: VoidLifeCycle<Instance>): this;
     on<Event extends LifeCycleEvent = LifeCycleEvent>(type: Event, handler: LifeCycle<Instance>[Event]): this;
-    group<NewElysia extends Elysia<any> = Elysia<any>, Prefix extends string = string>(prefix: Prefix, run: (group: Elysia<{
-        path: `${Instance['path']}${Prefix}`;
+    group<NewElysia extends Elysia<any, any> = Elysia<any, any>, Prefix extends string = string>(prefix: Prefix, run: (group: Elysia<`${BasePath}${Prefix}`, {
         error: Instance['error'];
         request: Instance['request'];
         store: Instance['store'] & ElysiaInstance['store'];
@@ -90,8 +92,7 @@ export default class Elysia<Instance extends ElysiaInstance = {
             defs: Instance['meta']['defs'];
             exposed: {};
         };
-    }>) => NewElysia): NewElysia extends Elysia<infer NewInstance> ? Elysia<{
-        path: Instance['path'];
+    }>) => NewElysia): NewElysia extends Elysia<`${BasePath}${Prefix}`, infer NewInstance> ? Elysia<BasePath, {
         error: Instance['error'];
         request: Instance['request'];
         schema: Instance['schema'];
@@ -100,8 +101,7 @@ export default class Elysia<Instance extends ElysiaInstance = {
             [key in keyof NewInstance['meta']['schema'] as key extends `${infer Rest}` ? `${Prefix}${Rest}` : key]: NewInstance['meta']['schema'][key];
         }>);
     }> : this;
-    group<Schema extends TypedSchema<Exclude<keyof Instance['meta']['defs'], number | symbol>>, NewElysia extends Elysia<any> = Elysia<any>, Prefix extends string = string>(prefix: Prefix, schema: LocalHook<Schema, Instance, `${Instance['path']}${Prefix}`>, run: (group: Elysia<{
-        path: `${Instance['path']}${Prefix}`;
+    group<Schema extends TypedSchema<Exclude<keyof Instance['meta']['defs'], number | symbol>>, NewElysia extends Elysia<any, any> = Elysia<any, any>, Prefix extends string = string>(prefix: Prefix, schema: LocalHook<Schema, Instance, `${BasePath}${Prefix}`>, run: (group: Elysia<`${BasePath}${Prefix}`, {
         error: Instance['error'];
         request: Instance['request'];
         store: Instance['store'] & ElysiaInstance['store'];
@@ -117,16 +117,16 @@ export default class Elysia<Instance extends ElysiaInstance = {
             defs: Instance['meta']['defs'];
             exposed: {};
         };
-    }>) => NewElysia): NewElysia extends Elysia<infer NewInstance> ? Elysia<{
-        path: Instance['path'];
+    }>) => NewElysia): NewElysia extends Elysia<`${BasePath}${Prefix}`, infer NewInstance> ? Elysia<BasePath, {
         error: Instance['error'];
         request: Instance['request'];
         schema: Instance['schema'];
         store: Instance['store'];
-        meta: Instance['meta'] & NewInstance['meta'];
+        meta: Instance['meta'] & (Omit<NewInstance['meta'], 'schema'> & Record<'schema', {
+            [key in keyof NewInstance['meta']['schema'] as key extends `${infer Rest}` ? `${Prefix}${Rest}` : key]: NewInstance['meta']['schema'][key];
+        }>);
     }> : this;
-    guard<Schema extends TypedSchema<Exclude<keyof Instance['meta']['defs'], number | symbol>>>(hook: LocalHook<Schema, Instance>): Elysia<{
-        path: Instance['path'];
+    guard<Schema extends TypedSchema<Exclude<keyof Instance['meta']['defs'], number | symbol>>>(hook: LocalHook<Schema, Instance>): Elysia<any, {
         error: Instance['error'];
         request: Instance['request'];
         store: Instance['store'];
@@ -135,8 +135,7 @@ export default class Elysia<Instance extends ElysiaInstance = {
             [key in keyof Schema]: Schema[key];
         }>;
     }>;
-    guard<Schema extends TypedSchema<Exclude<keyof Instance['meta']['defs'], number | symbol>>, NewElysia extends Elysia<any> = Elysia<any>>(hook: LocalHook<Schema, Instance>, run: (group: Elysia<{
-        path: Instance['path'];
+    guard<Schema extends TypedSchema<Exclude<keyof Instance['meta']['defs'], number | symbol>>, NewElysia extends Elysia<any, any> = Elysia<any, any>>(hook: LocalHook<Schema, Instance>, run: (group: Elysia<BasePath, {
         error: Instance['error'];
         request: Instance['request'];
         store: Instance['store'];
@@ -148,8 +147,7 @@ export default class Elysia<Instance extends ElysiaInstance = {
             response: undefined extends Schema['response'] ? Instance['schema']['response'] : Schema['response'];
         };
         meta: Instance['meta'];
-    }>) => NewElysia): NewElysia extends Elysia<infer NewInstance> ? Elysia<{
-        path: Instance['path'];
+    }>) => NewElysia): NewElysia extends Elysia<any, infer NewInstance> ? Elysia<BasePath, {
         error: Instance['error'];
         request: Instance['request'];
         store: Instance['store'];
@@ -158,8 +156,7 @@ export default class Elysia<Instance extends ElysiaInstance = {
             [key in keyof NewInstance['meta']['schema']]: NewInstance['meta']['schema'][key];
         }>;
     }> : this;
-    use<NewInstance extends ElysiaInstance, Params extends Elysia = Elysia<any>>(plugin: MaybePromise<(app: Params extends Elysia<infer ParamsInstance> ? IsAny<ParamsInstance> extends true ? this : any : Params) => MaybePromise<Elysia<NewInstance>>>): Elysia<{
-        path: Instance['path'];
+    use<NewInstance extends ElysiaInstance, Params extends Elysia = Elysia<any>>(plugin: MaybePromise<(app: Params extends Elysia<infer ParamsInstance> ? IsAny<ParamsInstance> extends true ? this : any : Params) => MaybePromise<Elysia<any, NewInstance>>>): Elysia<BasePath, {
         error: Instance['error'] & NewInstance['error'];
         request: Reconciliation<Instance['request'], NewInstance['request']>;
         store: Reconciliation<Instance['store'], NewInstance['store']>;
@@ -170,8 +167,7 @@ export default class Elysia<Instance extends ElysiaInstance = {
             exposed: Instance['meta']['exposed'] & NewInstance['meta']['exposed'];
         };
     }>;
-    use<NewInstance extends ElysiaInstance>(instance: Elysia<NewInstance>): Elysia<{
-        path: NewInstance['path'];
+    use<NewInstance extends ElysiaInstance>(instance: Elysia<any, NewInstance>): Elysia<BasePath, {
         error: Instance['error'] & NewInstance['error'];
         request: Reconciliation<Instance['request'], NewInstance['request']>;
         store: Reconciliation<Instance['store'], NewInstance['store']>;
@@ -183,9 +179,8 @@ export default class Elysia<Instance extends ElysiaInstance = {
         };
     }>;
     use<LazyLoadElysia extends ElysiaInstance>(plugin: Promise<{
-        default: (elysia: Elysia<any>) => MaybePromise<Elysia<LazyLoadElysia>>;
-    }>): Elysia<{
-        path: Instance['path'];
+        default: (elysia: Elysia<any, any>) => MaybePromise<Elysia<any, LazyLoadElysia>>;
+    }>): Elysia<BasePath, {
         error: Instance['error'] & LazyLoadElysia['error'];
         request: Reconciliation<Instance['request'], LazyLoadElysia['request']>;
         store: Reconciliation<Instance['store'], LazyLoadElysia['store']>;
@@ -197,9 +192,8 @@ export default class Elysia<Instance extends ElysiaInstance = {
         };
     }>;
     use<LazyLoadElysia extends ElysiaInstance>(plugin: Promise<{
-        default: (elysia: Elysia<any>) => Elysia<LazyLoadElysia>;
-    }>): Elysia<{
-        path: Instance['path'];
+        default: (elysia: Elysia<any, any>) => Elysia<any, LazyLoadElysia>;
+    }>): Elysia<BasePath, {
         error: Instance['error'] & LazyLoadElysia['error'];
         request: Reconciliation<Instance['request'], LazyLoadElysia['request']>;
         store: Reconciliation<Instance['store'], LazyLoadElysia['store']>;
@@ -212,8 +206,7 @@ export default class Elysia<Instance extends ElysiaInstance = {
     }>;
     mount(handle: (request: Request) => MaybePromise<Response>): this;
     mount(path: string, handle: (request: Request) => MaybePromise<Response>): this;
-    get<Path extends string, Handler extends LocalHandler<Schema, Instance, `${Instance['path']}${Path}`>, Schema extends TypedSchema<Extract<keyof Instance['meta']['defs'], string>>>(path: Path, handler: Handler, hook?: LocalHook<Schema, Instance, `${Instance['path']}${Path}`>): Elysia<{
-        path: Instance['path'];
+    get<Path extends string, Handler extends LocalHandler<Schema, Instance, `${BasePath}${Path}`>, Schema extends TypedSchema<Extract<keyof Instance['meta']['defs'], string>>>(path: Path, handler: Handler, hook?: LocalHook<Schema, Instance, `${BasePath}${Path}`>): Elysia<BasePath, {
         request: Instance['request'];
         store: Instance['store'];
         schema: Instance['schema'];
@@ -222,7 +215,7 @@ export default class Elysia<Instance extends ElysiaInstance = {
             defs: Instance['meta']['defs'];
             exposed: Instance['meta']['exposed'];
             schema: Prettify<Instance['meta']['schema'] & (MergeSchema<Schema, Instance['schema']> extends infer Typed extends TypedSchema ? {
-                [path in `${Instance['path']}${Path}`]: {
+                [path in Path]: {
                     get: {
                         body: UnwrapSchema<Typed['body'], Instance['meta']['defs']>;
                         headers: UnwrapSchema<Typed['headers'], Instance['meta']['defs']> extends infer Result ? Result extends Record<string, any> ? Result : undefined : undefined;
@@ -240,14 +233,13 @@ export default class Elysia<Instance extends ElysiaInstance = {
             } : {})>;
         };
     }>;
-    post<Path extends string, Handler extends LocalHandler<Schema, Instance, `${Instance['path']}${Path}`>, Schema extends TypedSchema<Extract<keyof Instance['meta']['defs'], string>>>(path: Path, handler: Handler, hook?: LocalHook<Schema, Instance, `${Instance['path']}${Path}`>): Elysia<{
-        path: Instance['path'];
+    post<Path extends string, Handler extends LocalHandler<Schema, Instance, `${BasePath}${Path}`>, Schema extends TypedSchema<Extract<keyof Instance['meta']['defs'], string>>>(path: Path, handler: Handler, hook?: LocalHook<Schema, Instance, `${BasePath}${Path}`>): Elysia<BasePath, {
         request: Instance['request'];
         store: Instance['store'];
         schema: Instance['schema'];
         error: Instance['error'];
         meta: Record<'defs', Instance['meta']['defs']> & Record<'exposed', Instance['meta']['exposed']> & Record<'schema', Prettify<Instance['meta']['schema'] & (MergeSchema<Schema, Instance['schema']> extends infer Typed extends TypedSchema ? {
-            [path in `${Instance['path']}${Path}`]: {
+            [path in Path]: {
                 post: {
                     handler?: Handler;
                     body: UnwrapSchema<Typed['body'], Instance['meta']['defs']>;
@@ -265,14 +257,13 @@ export default class Elysia<Instance extends ElysiaInstance = {
             };
         } : {})>>;
     }>;
-    put<Path extends string, Handler extends LocalHandler<Schema, Instance, `${Instance['path']}${Path}`>, Schema extends TypedSchema<Extract<keyof Instance['meta']['defs'], string>>>(path: Path, handler: Handler, hook?: LocalHook<Schema, Instance, `${Instance['path']}${Path}`>): Elysia<{
-        path: Instance['path'];
+    put<Path extends string, Handler extends LocalHandler<Schema, Instance, `${BasePath}${Path}`>, Schema extends TypedSchema<Extract<keyof Instance['meta']['defs'], string>>>(path: Path, handler: Handler, hook?: LocalHook<Schema, Instance, `${BasePath}${Path}`>): Elysia<BasePath, {
         request: Instance['request'];
         store: Instance['store'];
         schema: Instance['schema'];
         error: Instance['error'];
         meta: Record<'defs', Instance['meta']['defs']> & Record<'exposed', Instance['meta']['exposed']> & Record<'schema', Prettify<Instance['meta']['schema'] & (MergeSchema<Schema, Instance['schema']> extends infer Typed extends TypedSchema ? {
-            [path in `${Instance['path']}${Path}`]: {
+            [path in Path]: {
                 put: {
                     body: UnwrapSchema<Typed['body'], Instance['meta']['defs']>;
                     headers: UnwrapSchema<Typed['headers'], Instance['meta']['defs']> extends infer Result ? Result extends Record<string, any> ? Result : undefined : undefined;
@@ -289,14 +280,13 @@ export default class Elysia<Instance extends ElysiaInstance = {
             };
         } : {})>>;
     }>;
-    patch<Path extends string, Handler extends LocalHandler<Schema, Instance, `${Instance['path']}${Path}`>, Schema extends TypedSchema<Extract<keyof Instance['meta']['defs'], string>>>(path: Path, handler: Handler, hook?: LocalHook<Schema, Instance, `${Instance['path']}${Path}`>): Elysia<{
-        path: Instance['path'];
+    patch<Path extends string, Handler extends LocalHandler<Schema, Instance, `${BasePath}${Path}`>, Schema extends TypedSchema<Extract<keyof Instance['meta']['defs'], string>>>(path: Path, handler: Handler, hook?: LocalHook<Schema, Instance, `${BasePath}${Path}`>): Elysia<BasePath, {
         request: Instance['request'];
         store: Instance['store'];
         schema: Instance['schema'];
         error: Instance['error'];
         meta: Record<'defs', Instance['meta']['defs']> & Record<'exposed', Instance['meta']['exposed']> & Record<'schema', Prettify<Instance['meta']['schema'] & (MergeSchema<Schema, Instance['schema']> extends infer Typed extends TypedSchema ? {
-            [path in `${Instance['path']}${Path}`]: {
+            [path in Path]: {
                 patch: {
                     body: UnwrapSchema<Typed['body'], Instance['meta']['defs']>;
                     headers: UnwrapSchema<Typed['headers'], Instance['meta']['defs']> extends infer Result ? Result extends Record<string, any> ? Result : undefined : undefined;
@@ -313,14 +303,13 @@ export default class Elysia<Instance extends ElysiaInstance = {
             };
         } : {})>>;
     }>;
-    delete<Path extends string, Handler extends LocalHandler<Schema, Instance, `${Instance['path']}${Path}`>, Schema extends TypedSchema<Extract<keyof Instance['meta']['defs'], string>>>(path: Path, handler: Handler, hook?: LocalHook<Schema, Instance, `${Instance['path']}${Path}`>): Elysia<{
-        path: Instance['path'];
+    delete<Path extends string, Handler extends LocalHandler<Schema, Instance, `${BasePath}${Path}`>, Schema extends TypedSchema<Extract<keyof Instance['meta']['defs'], string>>>(path: Path, handler: Handler, hook?: LocalHook<Schema, Instance, `${BasePath}${Path}`>): Elysia<BasePath, {
         request: Instance['request'];
         store: Instance['store'];
         schema: Instance['schema'];
         error: Instance['error'];
         meta: Record<'defs', Instance['meta']['defs']> & Record<'exposed', Instance['meta']['exposed']> & Record<'schema', Prettify<Instance['meta']['schema'] & (MergeSchema<Schema, Instance['schema']> extends infer Typed extends TypedSchema ? {
-            [path in `${Instance['path']}${Path}`]: {
+            [path in Path]: {
                 delete: {
                     body: UnwrapSchema<Typed['body'], Instance['meta']['defs']>;
                     headers: UnwrapSchema<Typed['headers'], Instance['meta']['defs']> extends infer Result ? Result extends Record<string, any> ? Result : undefined : undefined;
@@ -337,14 +326,13 @@ export default class Elysia<Instance extends ElysiaInstance = {
             };
         } : {})>>;
     }>;
-    options<Path extends string, Handler extends LocalHandler<Schema, Instance, `${Instance['path']}${Path}`>, Schema extends TypedSchema<Extract<keyof Instance['meta']['defs'], string>>>(path: Path, handler: Handler, hook?: LocalHook<Schema, Instance, `${Instance['path']}${Path}`>): Elysia<{
-        path: Instance['path'];
+    options<Path extends string, Handler extends LocalHandler<Schema, Instance, `${BasePath}${Path}`>, Schema extends TypedSchema<Extract<keyof Instance['meta']['defs'], string>>>(path: Path, handler: Handler, hook?: LocalHook<Schema, Instance, `${BasePath}${Path}`>): Elysia<BasePath, {
         request: Instance['request'];
         store: Instance['store'];
         schema: Instance['schema'];
         error: Instance['error'];
         meta: Record<'defs', Instance['meta']['defs']> & Record<'exposed', Instance['meta']['exposed']> & Record<'schema', Prettify<Instance['meta']['schema'] & (MergeSchema<Schema, Instance['schema']> extends infer Typed extends TypedSchema ? {
-            [path in `${Instance['path']}${Path}`]: {
+            [path in Path]: {
                 options: {
                     body: UnwrapSchema<Typed['body'], Instance['meta']['defs']>;
                     headers: UnwrapSchema<Typed['headers'], Instance['meta']['defs']> extends infer Result ? Result extends Record<string, any> ? Result : undefined : undefined;
@@ -361,14 +349,13 @@ export default class Elysia<Instance extends ElysiaInstance = {
             };
         } : {})>>;
     }>;
-    all<Path extends string, Handler extends LocalHandler<Schema, Instance, `${Instance['path']}${Path}`>, Schema extends TypedSchema<Extract<keyof Instance['meta']['defs'], string>>>(path: Path, handler: Handler, hook?: LocalHook<Schema, Instance, `${Instance['path']}${Path}`>): Elysia<{
-        path: Instance['path'];
+    all<Path extends string, Handler extends LocalHandler<Schema, Instance, `${BasePath}${Path}`>, Schema extends TypedSchema<Extract<keyof Instance['meta']['defs'], string>>>(path: Path, handler: Handler, hook?: LocalHook<Schema, Instance, `${BasePath}${Path}`>): Elysia<BasePath, {
         request: Instance['request'];
         store: Instance['store'];
         schema: Instance['schema'];
         error: Instance['error'];
         meta: Record<'defs', Instance['meta']['defs']> & Record<'exposed', Instance['meta']['exposed']> & Record<'schema', Prettify<Instance['meta']['schema'] & (MergeSchema<Schema, Instance['schema']> extends infer Typed extends TypedSchema ? {
-            [path in `${Instance['path']}${Path}`]: {
+            [path in Path]: {
                 all: {
                     body: UnwrapSchema<Typed['body'], Instance['meta']['defs']>;
                     headers: UnwrapSchema<Typed['headers'], Instance['meta']['defs']> extends infer Result ? Result extends Record<string, any> ? Result : undefined : undefined;
@@ -385,14 +372,13 @@ export default class Elysia<Instance extends ElysiaInstance = {
             };
         } : {})>>;
     }>;
-    head<Path extends string, Handler extends LocalHandler<Schema, Instance, `${Instance['path']}${Path}`>, Schema extends TypedSchema<Extract<keyof Instance['meta']['defs'], string>>>(path: Path, handler: Handler, hook?: LocalHook<Schema, Instance, `${Instance['path']}${Path}`>): Elysia<{
-        path: Instance['path'];
+    head<Path extends string, Handler extends LocalHandler<Schema, Instance, `${BasePath}${Path}`>, Schema extends TypedSchema<Extract<keyof Instance['meta']['defs'], string>>>(path: Path, handler: Handler, hook?: LocalHook<Schema, Instance, `${BasePath}${Path}`>): Elysia<BasePath, {
         request: Instance['request'];
         store: Instance['store'];
         schema: Instance['schema'];
         error: Instance['error'];
         meta: Record<'defs', Instance['meta']['defs']> & Record<'exposed', Instance['meta']['exposed']> & Record<'schema', Prettify<Instance['meta']['schema'] & (MergeSchema<Schema, Instance['schema']> extends infer Typed extends TypedSchema ? {
-            [path in `${Instance['path']}${Path}`]: {
+            [path in Path]: {
                 head: {
                     body: UnwrapSchema<Typed['body'], Instance['meta']['defs']>;
                     headers: UnwrapSchema<Typed['headers'], Instance['meta']['defs']> extends infer Result ? Result extends Record<string, any> ? Result : undefined : undefined;
@@ -409,14 +395,13 @@ export default class Elysia<Instance extends ElysiaInstance = {
             };
         } : {})>>;
     }>;
-    trace<Path extends string, Handler extends LocalHandler<Schema, Instance, `${Instance['path']}${Path}`>, Schema extends TypedSchema<Extract<keyof Instance['meta']['defs'], string>>>(path: Path, handler: Handler, hook?: LocalHook<Schema, Instance, `${Instance['path']}${Path}`>): Elysia<{
-        path: Instance['path'];
+    trace<Path extends string, Handler extends LocalHandler<Schema, Instance, `${BasePath}${Path}`>, Schema extends TypedSchema<Extract<keyof Instance['meta']['defs'], string>>>(path: Path, handler: Handler, hook?: LocalHook<Schema, Instance, `${BasePath}${Path}`>): Elysia<BasePath, {
         request: Instance['request'];
         store: Instance['store'];
         schema: Instance['schema'];
         error: Instance['error'];
         meta: Record<'defs', Instance['meta']['defs']> & Record<'exposed', Instance['meta']['exposed']> & Record<'schema', Prettify<Instance['meta']['schema'] & (MergeSchema<Schema, Instance['schema']> extends infer Typed extends TypedSchema ? {
-            [path in `${Instance['path']}${Path}`]: {
+            [path in Path]: {
                 trace: {
                     body: UnwrapSchema<Typed['body'], Instance['meta']['defs']>;
                     headers: UnwrapSchema<Typed['headers'], Instance['meta']['defs']> extends infer Result ? Result extends Record<string, any> ? Result : undefined : undefined;
@@ -433,14 +418,13 @@ export default class Elysia<Instance extends ElysiaInstance = {
             };
         } : {})>>;
     }>;
-    connect<Path extends string, Handler extends LocalHandler<Schema, Instance, `${Instance['path']}${Path}`>, Schema extends TypedSchema<Extract<keyof Instance['meta']['defs'], string>>>(path: Path, handler: Handler, hook?: LocalHook<Schema, Instance, `${Instance['path']}${Path}`>): Elysia<{
-        path: Instance['path'];
+    connect<Path extends string, Handler extends LocalHandler<Schema, Instance, `${BasePath}${Path}`>, Schema extends TypedSchema<Extract<keyof Instance['meta']['defs'], string>>>(path: Path, handler: Handler, hook?: LocalHook<Schema, Instance, `${BasePath}${Path}`>): Elysia<BasePath, {
         request: Instance['request'];
         store: Instance['store'];
         schema: Instance['schema'];
         error: Instance['error'];
         meta: Record<'defs', Instance['meta']['defs']> & Record<'exposed', Instance['meta']['exposed']> & Record<'schema', Prettify<Instance['meta']['schema'] & (MergeSchema<Schema, Instance['schema']> extends infer Typed extends TypedSchema ? {
-            [path in `${Instance['path']}${Path}`]: {
+            [path in Path]: {
                 connect: {
                     body: UnwrapSchema<Typed['body'], Instance['meta']['defs']>;
                     headers: UnwrapSchema<Typed['headers'], Instance['meta']['defs']> extends infer Result ? Result extends Record<string, any> ? Result : undefined : undefined;
@@ -457,28 +441,26 @@ export default class Elysia<Instance extends ElysiaInstance = {
             };
         } : {})>>;
     }>;
-    ws<Path extends string, Schema extends WSTypedSchema<Extract<keyof Instance['meta']['defs'], string>>>(path: Path, options: Path extends '' ? never : this extends Elysia<infer Instance> ? ElysiaWSOptions<`${Instance['path']}${Path}`, Schema, Instance['meta']['defs']> : never): Elysia<{
-        path: Instance['path'];
+    ws<Path extends string, Schema extends WSTypedSchema<Extract<keyof Instance['meta']['defs'], string>>>(path: Path, options: this extends Elysia<any, infer Instance> ? ElysiaWSOptions<`${BasePath}${Path}`, Schema, Instance['meta']['defs']> : never): Elysia<BasePath, {
         request: Instance['request'];
         store: Instance['store'];
         schema: Instance['schema'];
         error: Instance['error'];
-        meta: Instance['meta'] & Record<'schema', Record<`${Instance['path']}${Path}`, MergeSchema<Schema, Instance['schema']> extends infer Typed extends TypedSchema ? {
-            subscribe: TypedWSRouteToEden<Typed, Instance['meta']['defs'], `${Instance['path']}${Path}`>;
+        meta: Instance['meta'] & Record<'schema', Record<Path, MergeSchema<Schema, Instance['schema']> extends infer Typed extends TypedSchema ? {
+            subscribe: TypedWSRouteToEden<Typed, Instance['meta']['defs'], `${BasePath}${Path}`>;
         } : {}>>;
     }>;
-    route<Schema extends TypedSchema<Exclude<keyof Instance['meta']['defs'], number | symbol>>, Method extends HTTPMethod, Path extends string, Handler extends LocalHandler<Schema, Instance, `${Instance['path']}${Path}`>>(method: Method, path: Path, handler: Handler, { config, ...hook }?: LocalHook<Schema, Instance, `${Instance['path']}${Path}`> & {
+    route<Schema extends TypedSchema<Exclude<keyof Instance['meta']['defs'], number | symbol>>, Method extends HTTPMethod, Path extends string, Handler extends LocalHandler<Schema, Instance, `${BasePath}${Path}`>>(method: Method, path: Path, handler: Handler, { config, ...hook }?: LocalHook<Schema, Instance, `${BasePath}${Path}`> & {
         config: {
             allowMeta?: boolean;
         };
-    }): Elysia<{
-        path: Instance['path'];
+    }): Elysia<BasePath, {
         request: Instance['request'];
         store: Instance['store'];
         schema: Instance['schema'];
         error: Instance['error'];
         meta: Record<'defs', Instance['meta']['defs']> & Record<'exposed', Instance['meta']['exposed']> & Record<'schema', Prettify<Instance['meta']['schema'] & MergeSchema<Schema, Instance['schema']> extends infer Typed extends TypedSchema ? {
-            [path in `${Instance['path']}${Path}`]: {
+            [path in Path]: {
                 [method in Method]: {
                     body: UnwrapSchema<Typed['body'], Instance['meta']['defs']>;
                     headers: UnwrapSchema<Typed['headers'], Instance['meta']['defs']> extends infer Result ? Result extends Record<string, any> ? Result : undefined : undefined;
@@ -495,32 +477,28 @@ export default class Elysia<Instance extends ElysiaInstance = {
             };
         } : never>>;
     }>;
-    state<Key extends string | number | symbol, Value>(name: Key, value: Value): Elysia<{
-        path: Instance['path'];
+    state<Key extends string | number | symbol, Value>(name: Key, value: Value): Elysia<BasePath, {
         store: Reconciliation<Instance['store'], Record<Key, Value>>;
         error: Instance['error'];
         request: Instance['request'];
         schema: Instance['schema'];
         meta: Instance['meta'];
     }>;
-    state<NewStore extends Record<string, unknown>>(store: NewStore): Elysia<{
-        path: Instance['path'];
+    state<NewStore extends Record<string, unknown>>(store: NewStore): Elysia<BasePath, {
         store: Reconciliation<Instance['store'], DeepWritable<NewStore>>;
         error: Instance['error'];
         request: Instance['request'];
         schema: Instance['schema'];
         meta: Instance['meta'];
     }>;
-    decorate<const Name extends string, const Value>(name: Name, value: Value): Elysia<{
-        path: Instance['path'];
+    decorate<const Name extends string, const Value>(name: Name, value: Value): Elysia<BasePath, {
         store: Instance['store'];
         error: Instance['error'];
         request: Reconciliation<Instance['request'], Record<Name, Value>>;
         schema: Instance['schema'];
         meta: Instance['meta'];
     }>;
-    decorate<const Decorators extends Record<string, unknown>>(name: Decorators): Elysia<{
-        path: Instance['path'];
+    decorate<const Decorators extends Record<string, unknown>>(name: Decorators): Elysia<BasePath, {
         store: Instance['store'];
         error: Instance['error'];
         request: Reconciliation<Instance['request'], DeepWritable<Decorators>>;
@@ -529,16 +507,14 @@ export default class Elysia<Instance extends ElysiaInstance = {
     }>;
     derive<Returned extends Object = Object>(transform: (context: Context<TypedSchemaToRoute<Instance['schema'], Instance['meta']['defs']>, Instance['store']> & Instance['request']) => MaybePromise<Returned> extends {
         store: any;
-    } ? never : Returned): Elysia<{
-        path: Instance['path'];
+    } ? never : Returned): Elysia<BasePath, {
         store: Instance['store'];
         error: Instance['error'];
         request: Instance['request'] & Awaited<Returned>;
         schema: Instance['schema'];
         meta: Instance['meta'];
     }>;
-    schema<Schema extends TypedSchema<Exclude<keyof Instance['meta']['defs'], number | symbol>> = TypedSchema<Exclude<keyof Instance['meta']['defs'], number | symbol>>, NewInstance = Elysia<{
-        path: Instance['path'];
+    schema<Schema extends TypedSchema<Exclude<keyof Instance['meta']['defs'], number | symbol>> = TypedSchema<Exclude<keyof Instance['meta']['defs'], number | symbol>>, NewInstance = Elysia<BasePath, {
         request: Instance['request'];
         store: Instance['store'];
         error: Instance['error'];
@@ -552,9 +528,8 @@ export default class Elysia<Instance extends ElysiaInstance = {
     private outerErrorHandler;
     listen: (options: string | number | Partial<Serve>, callback?: ListenCallback) => this;
     stop: () => Promise<void>;
-    get modules(): Promise<Elysia<any>[]>;
-    model<Name extends string, Model extends TSchema>(name: Name, model: Model): Elysia<{
-        path: Instance['path'];
+    get modules(): Promise<Elysia<any, any>[]>;
+    model<Name extends string, Model extends TSchema>(name: Name, model: Model): Elysia<BasePath, {
         store: Instance['store'];
         request: Instance['request'];
         schema: Instance['schema'];
@@ -565,8 +540,7 @@ export default class Elysia<Instance extends ElysiaInstance = {
             exposed: Instance['meta']['exposed'];
         };
     }>;
-    model<Recorder extends Record<string, TSchema>>(record: Recorder): Elysia<{
-        path: Instance['path'];
+    model<Recorder extends Record<string, TSchema>>(record: Recorder): Elysia<BasePath, {
         store: Instance['store'];
         request: Instance['request'];
         schema: Instance['schema'];