spiceflow 0.0.6 → 1.0.0

package/dist/elysia-fork/types.d.ts

@@ -0,0 +1,652 @@
+/// <reference types="bun-types" />
+/// <reference types="bun-types" />
+import type { BunFile, Server } from 'bun';
+import type { TSchema, Static, TAnySchema, StaticDecode, OptionalKind } from '@sinclair/typebox';
+import type { TypeCheck, ValueError } from '@sinclair/typebox/compiler';
+import type { OpenAPIV3 } from 'openapi-types';
+import type { Context, ErrorContext, PreContext } from './context';
+import { ELYSIA_RESPONSE, InternalServerError, InvalidCookieSignature, NotFoundError, ParseError, ValidationError } from './error';
+import { Elysia } from '../spiceflow';
+export type ElysiaConfig<Prefix extends string | undefined, Scoped extends boolean | undefined> = {
+    /**
+     * Path prefix of the instance
+     *
+     * @default '''
+     */
+    prefix?: Prefix;
+    /**
+     * If set to true, other Elysia handler will not inherits global life-cycle, store, decorators from the current instance
+     *
+     * @default false
+     */
+    scoped?: Scoped;
+    /**
+     * Name of the instance for debugging, and plugin deduplication purpose
+     */
+    name?: string;
+    /**
+     * Seed for generating checksum for plugin deduplication
+     *
+     * @see https://elysiajs.com/essential/plugin.html#plugin-deduplication
+     */
+    seed?: unknown;
+    /**
+     * OpenAPI documentation (use in Swagger)
+     *
+     * @see https://swagger.io/specification/
+     */
+    detail?: DocumentDecoration;
+    /**
+     * OpenAPI tags
+     *
+     * current instance' routes with tags
+     *
+     * @see https://swagger.io/specification/#tag-object
+     */
+    tags?: DocumentDecoration['tags'];
+    /**
+     * Warm up Elysia before starting the server
+     *
+     * This will perform Ahead of Time compilation and generate code for route handlers
+     *
+     * If set to false, Elysia will perform Just in Time compilation
+     *
+     * Only required for root instance (instance which use listen) to effect
+     *
+     * ! If performing a benchmark, it's recommended to set this to `true`
+     *
+     * @default false
+     */
+    precompile?: boolean | {
+        /**
+         * Perform dynamic code generation for route handlers before starting the server
+         *
+         * @default false
+         */
+        compose?: boolean;
+        /**
+         * Perform Ahead of Time compilation for schema before starting the server
+         *
+         * @default false
+         */
+        schema?: boolean;
+    };
+    /**
+     * Capture more detail information for each dependencies
+     */
+    analytic?: boolean;
+    /**
+     * Enable experimental features
+     */
+    experimental?: {};
+    /**
+     * If enabled, the handlers will run a [clean](https://github.com/sinclairzx81/typebox?tab=readme-ov-file#clean) on incoming and outgoing bodies instead of failing directly.
+     * This allows for sending unknown or disallowed properties in the bodies. These will simply be filtered out instead of failing the request.
+     * This has no effect when the schemas allow additional properties.
+     * Since this uses dynamic schema it may have an impact on performance.
+     *
+     * @default false
+     */
+    normalize?: boolean;
+};
+export type MaybeArray<T> = T | T[];
+export type MaybePromise<T> = T | Promise<T>;
+export type ObjectValues<T extends object> = T[keyof T];
+type IsPathParameter<Part extends string> = Part extends `:${infer Parameter}` ? Parameter : Part extends `*` ? '*' : never;
+export type GetPathParameter<Path extends string> = Path extends `${infer A}/${infer B}` ? IsPathParameter<A> | GetPathParameter<B> : IsPathParameter<Path>;
+export type ResolvePath<Path extends string> = Prettify<{
+    [Param in GetPathParameter<Path> as Param extends `${string}?` ? never : Param]: string;
+} & {
+    [Param in GetPathParameter<Path> as Param extends `${infer OptionalParam}?` ? OptionalParam : never]?: string;
+}>;
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export type Prettify2<T> = {
+    [K in keyof T]: Prettify<T[K]>;
+} & {};
+export type Partial2<T> = {
+    [K in keyof T]?: Partial<T[K]>;
+};
+export type NeverKey<T> = {
+    [K in keyof T]?: T[K];
+} & {};
+type IsBothObject<A, B> = A extends Record<string | number | symbol, unknown> ? B extends Record<string | number | symbol, unknown> ? IsClass<A> extends false ? IsClass<B> extends false ? true : false : false : false : false;
+type IsClass<V> = V extends abstract new (...args: any) => any ? true : false;
+export type Reconcile<A extends Object, B extends Object, Override extends boolean = false, Stack extends number[] = []> = Stack['length'] extends 16 ? A : Override extends true ? {
+    [key in keyof A as key extends keyof B ? never : key]: A[key];
+} extends infer Collision ? {} extends Collision ? {
+    [key in keyof B]: IsBothObject<A[key], B[key]> extends true ? Reconcile<A[key], B[key], Override, [
+        0,
+        ...Stack
+    ]> : B[key];
+} : Prettify<Collision & {
+    [key in keyof B]: B[key];
+}> : never : {
+    [key in keyof B as key extends keyof A ? never : key]: B[key];
+} extends infer Collision ? {} extends Collision ? {
+    [key in keyof A]: IsBothObject<A[key], B[key]> extends true ? Reconcile<A[key], B[key], Override, [
+        0,
+        ...Stack
+    ]> : A[key];
+} : Prettify<{
+    [key in keyof A]: A[key];
+} & Collision> : never;
+export interface SingletonBase {
+    decorator: Record<string, unknown>;
+    store: Record<string, unknown>;
+    derive: Record<string, unknown>;
+    resolve: Record<string, unknown>;
+}
+export interface EphemeralType {
+    derive: SingletonBase['derive'];
+    resolve: SingletonBase['resolve'];
+    schema: MetadataBase['schema'];
+}
+export interface DefinitionBase {
+    type: Record<string, unknown>;
+    error: Record<string, Error>;
+}
+export type RouteBase = Record<string, unknown>;
+export interface MetadataBase {
+    schema: RouteSchema;
+    macro: BaseMacro;
+    macroFn: BaseMacroFn;
+}
+export interface RouteSchema {
+    body?: unknown;
+    headers?: unknown;
+    query?: unknown;
+    params?: unknown;
+    cookie?: unknown;
+    response?: unknown;
+}
+type OptionalField = {
+    [OptionalKind]: 'Optional';
+};
+export type UnwrapSchema<Schema extends TSchema | string | undefined, Definitions extends Record<string, unknown> = {}> = undefined extends Schema ? unknown : Schema extends TSchema ? Schema extends OptionalField ? Prettify<Partial<Static<Schema>>> : StaticDecode<Schema> : Schema extends string ? Definitions extends Record<Schema, infer NamedSchema> ? NamedSchema : Definitions : unknown;
+export type UnwrapBodySchema<Schema extends TSchema | string | undefined, Definitions extends Record<string, unknown> = {}> = undefined extends Schema ? unknown : Schema extends TSchema ? Schema extends OptionalField ? Prettify<Partial<Static<Schema>>> | null : StaticDecode<Schema> : Schema extends string ? Definitions extends Record<Schema, infer NamedSchema> ? NamedSchema : Definitions : unknown;
+export interface UnwrapRoute<in out Schema extends InputSchema<any>, in out Definitions extends DefinitionBase['type'] = {}> {
+    body: UnwrapBodySchema<Schema['body'], Definitions>;
+    response: Schema['response'] extends TSchema | string ? {
+        200: CoExist<UnwrapSchema<Schema['response'], Definitions>, File, BunFile>;
+    } : Schema['response'] extends Record<number, TAnySchema | string> ? {
+        [k in keyof Schema['response']]: CoExist<UnwrapSchema<Schema['response'][k], Definitions>, File, BunFile>;
+    } : unknown | void;
+}
+export type HookContainer<T extends Function = Function> = {
+    checksum?: number;
+    scope?: LifeCycleType;
+    subType?: 'derive' | 'resolve' | 'mapDerive' | 'mapResolve' | (string & {});
+    fn: T;
+};
+export interface LifeCycleStore {
+    type?: ContentType;
+    start: HookContainer<GracefulHandler<any>>[];
+    request: HookContainer<PreHandler<any, any>>[];
+    parse: HookContainer<BodyHandler<any, any>>[];
+    transform: HookContainer<TransformHandler<any, any>>[];
+    beforeHandle: HookContainer<OptionalHandler<any, any>>[];
+    afterHandle: HookContainer<AfterHandler<any, any>>[];
+    mapResponse: HookContainer<MapResponse<any, any>>[];
+    afterResponse: HookContainer<AfterResponseHandler<any, any>>[];
+    error: HookContainer<ErrorHandler<any, any, any>>[];
+    stop: HookContainer<GracefulHandler<any>>[];
+}
+export type LifeCycleEvent = 'start' | 'request' | 'parse' | 'transform' | 'beforeHandle' | 'afterHandle' | 'response' | 'error' | 'stop';
+export type ContentType = MaybeArray<(string & {}) | 'none' | 'text' | 'json' | 'formdata' | 'urlencoded' | 'arrayBuffer' | 'text/plain' | 'application/json' | 'multipart/form-data' | 'application/x-www-form-urlencoded'>;
+export type HTTPMethod = (string & {}) | 'ACL' | 'BIND' | 'CHECKOUT' | 'CONNECT' | 'COPY' | 'DELETE' | 'GET' | 'HEAD' | 'LINK' | 'LOCK' | 'M-SEARCH' | 'MERGE' | 'MKACTIVITY' | 'MKCALENDAR' | 'MKCOL' | 'MOVE' | 'NOTIFY' | 'OPTIONS' | 'PATCH' | 'POST' | 'PROPFIND' | 'PROPPATCH' | 'PURGE' | 'PUT' | 'REBIND' | 'REPORT' | 'SEARCH' | 'SOURCE' | 'SUBSCRIBE' | 'TRACE' | 'UNBIND' | 'UNLINK' | 'UNLOCK' | 'UNSUBSCRIBE' | 'ALL';
+export interface InputSchema<Name extends string = string> {
+    body?: TSchema | Name;
+    response?: TSchema | Record<number, TSchema> | Name | Record<number, Name | TSchema>;
+}
+export interface MergeSchema<in out A extends RouteSchema, in out B extends RouteSchema> {
+    body: undefined extends A['body'] ? B['body'] : A['body'];
+    headers: undefined extends A['headers'] ? B['headers'] : A['headers'];
+    query: undefined extends A['query'] ? B['query'] : A['query'];
+    params: undefined extends A['params'] ? B['params'] : A['params'];
+    cookie: undefined extends A['cookie'] ? B['cookie'] : A['cookie'];
+    response: {} extends A['response'] ? {} extends B['response'] ? {} : B['response'] : {} extends B['response'] ? A['response'] : A['response'] & Omit<B['response'], keyof A['response']>;
+}
+export type Handler<in out Route extends RouteSchema = {}, in out Singleton extends SingletonBase = {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, Path extends string = ''> = (context: Context<Route, Singleton, Path>) => MaybePromise<{} extends Route['response'] ? unknown : Route['response'][keyof Route['response']]>;
+export type Replace<Original, Target, With> = IsAny<Target> extends true ? Original : Original extends Record<string, unknown> ? {
+    [K in keyof Original]: Original[K] extends Target ? With : Original[K];
+} : Original extends Target ? With : Original;
+type IsAny<T> = 0 extends 1 & T ? true : false;
+export type CoExist<Original, Target, With> = IsAny<Target> extends true ? Original : Original extends Record<string, unknown> ? {
+    [K in keyof Original]: Original[K] extends Target ? Original[K] | With : Original[K];
+} : Original extends Target ? Original | With : Original;
+export type InlineHandler<Route extends RouteSchema = {}, Singleton extends SingletonBase = {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, Path extends string = '', MacroContext = {}> = ((context: MacroContext extends Record<string | number | symbol, unknown> ? Prettify<MacroContext & Context<Route, Singleton, Path>> : Context<Route, Singleton, Path>) => Response | MaybePromise<{} extends Route['response'] ? unknown : (Route['response'] extends {
+    200: any;
+} ? Route['response'] : string | number | boolean | Object) | Route['response'][keyof Route['response']] | {
+    [Status in keyof Route['response']]: {
+        _type: Record<Status, Route['response'][Status]>;
+        [ELYSIA_RESPONSE]: Status;
+    };
+}[keyof Route['response']]>) | ({} extends Route['response'] ? string | number | boolean | Object : (Route['response'] extends {
+    200: any;
+} ? Route['response'] : string | number | boolean | Object) | Route['response'][keyof Route['response']] | {
+    [Status in keyof Route['response']]: {
+        _type: Record<Status, Route['response'][Status]>;
+        [ELYSIA_RESPONSE]: Status;
+    };
+}[keyof Route['response']]);
+export type OptionalHandler<in out Route extends RouteSchema = {}, in out Singleton extends SingletonBase = {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, Path extends string = ''> = Handler<Route, Singleton, Path> extends (context: infer Context) => infer Returned ? (context: Context) => Returned | MaybePromise<void> : never;
+export type AfterHandler<in out Route extends RouteSchema = {}, in out Singleton extends SingletonBase = {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, Path extends string = ''> = Handler<Route, Singleton, Path> extends (context: infer Context) => infer Returned ? (context: Prettify<{
+    response: Route['response'];
+} & Context>) => Returned | MaybePromise<void> : never;
+export type MapResponse<in out Route extends RouteSchema = {}, in out Singleton extends SingletonBase = {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, Path extends string = ''> = Handler<Omit<Route, 'response'> & {
+    response: MaybePromise<Response | undefined | unknown>;
+}, Singleton & {
+    derive: {
+        response: Route['response'];
+    };
+}, Path>;
+export type VoidHandler<in out Route extends RouteSchema = {}, in out Singleton extends SingletonBase = {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}> = (context: Context<Route, Singleton>) => MaybePromise<void>;
+export type TransformHandler<in out Route extends RouteSchema = {}, in out Singleton extends SingletonBase = {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, BasePath extends string = ''> = {
+    (context: Prettify<Context<Route, Omit<Singleton, 'resolve'> & {
+        resolve: {};
+    }, BasePath>>): MaybePromise<void>;
+};
+export type BodyHandler<in out Route extends RouteSchema = {}, in out Singleton extends SingletonBase = {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, Path extends string = ''> = (context: Prettify<{
+    contentType: string;
+} & Context<Route, Singleton, Path>>, 
+/**
+ * @deprecated
+ *
+ * use `context.contentType` instead
+ *
+ * @example
+ * ```ts
+ * new Elysia()
+ * 	   .onParse(({ contentType, request }) => {
+ * 		     if (contentType === 'application/json')
+ * 			     return request.json()
+ *     })
+ * ```
+ */
+contentType: string) => MaybePromise<any>;
+export type PreHandler<in out Route extends RouteSchema = {}, in out Singleton extends SingletonBase = {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}> = (context: PreContext<Singleton>) => MaybePromise<Route['response'] | void>;
+export type AfterResponseHandler<in out Route extends RouteSchema = {}, in out Singleton extends SingletonBase = {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}> = (context: Prettify<Context<Route, Singleton> & {
+    response: Route['response'];
+}>) => MaybePromise<void>;
+export type GracefulHandler<in Instance extends Elysia<any, any, any, any, any, any, any, any>> = (data: Instance) => any;
+export type ErrorHandler<in out T extends Record<string, Error> = {}, in out Route extends RouteSchema = {}, in out Singleton extends SingletonBase = {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, in out Ephemeral extends EphemeralType = {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, in out Volatile extends EphemeralType = {
+    derive: {};
+    resolve: {};
+    schema: {};
+}> = (context: ErrorContext<Route, {
+    store: Singleton['store'];
+    decorator: Singleton['decorator'];
+    derive: {};
+    resolve: {};
+}> & (Prettify<{
+    request: Request;
+    code: 'UNKNOWN';
+    error: Readonly<Error>;
+} & Partial<Singleton['derive'] & Ephemeral['derive'] & Volatile['derive']> & Partial<Singleton['derive'] & Ephemeral['resolve'] & Volatile['resolve']>> | Prettify<{
+    request: Request;
+    code: 'VALIDATION';
+    error: Readonly<ValidationError>;
+} & Singleton['derive'] & Ephemeral['derive'] & Volatile['derive'] & NeverKey<Singleton['derive'] & Ephemeral['resolve'] & Volatile['resolve']>> | Prettify<{
+    request: Request;
+    code: 'NOT_FOUND';
+    error: Readonly<NotFoundError>;
+} & NeverKey<Singleton['derive'] & Ephemeral['derive'] & Volatile['derive']> & NeverKey<Singleton['derive'] & Ephemeral['resolve'] & Volatile['resolve']>> | Prettify<{
+    request: Request;
+    code: 'PARSE';
+    error: Readonly<ParseError>;
+} & Singleton['derive'] & Ephemeral['derive'] & Volatile['derive'] & NeverKey<Singleton['derive'] & Ephemeral['resolve'] & Volatile['resolve']>> | Prettify<{
+    request: Request;
+    code: 'INTERNAL_SERVER_ERROR';
+    error: Readonly<InternalServerError>;
+} & Partial<Singleton['derive'] & Ephemeral['derive'] & Volatile['derive']> & Partial<Singleton['derive'] & Ephemeral['resolve'] & Volatile['resolve']>> | Prettify<{
+    request: Request;
+    code: 'INVALID_COOKIE_SIGNATURE';
+    error: Readonly<InvalidCookieSignature>;
+} & NeverKey<Singleton['derive'] & Ephemeral['derive'] & Volatile['derive']> & NeverKey<Singleton['derive'] & Ephemeral['resolve'] & Volatile['resolve']>> | Prettify<{
+    [K in keyof T]: {
+        request: Request;
+        code: K;
+        error: Readonly<T[K]>;
+    };
+}[keyof T] & Partial<Singleton['derive'] & Ephemeral['derive'] & Volatile['derive']> & Partial<Singleton['derive'] & Ephemeral['resolve'] & Volatile['resolve']>>)) => any | Promise<any>;
+export type Isolate<T> = {
+    [P in keyof T]: T[P];
+};
+export type DocumentDecoration = Partial<OpenAPIV3.OperationObject> & {
+    /**
+     * Pass `true` to hide route from OpenAPI/swagger document
+     * */
+    hide?: boolean;
+};
+export type LocalHook<LocalSchema extends InputSchema, Schema extends RouteSchema, Singleton extends SingletonBase, Errors extends Record<string, Error>, Extension extends BaseMacro, Path extends string = '', TypedRoute extends RouteSchema = Schema extends {
+    params: Record<string, unknown>;
+} ? Schema : Schema & {
+    params: undefined extends Schema['params'] ? ResolvePath<Path> : Schema['params'];
+}> = (LocalSchema extends {} ? LocalSchema : Isolate<LocalSchema>) & Extension & {
+    /**
+     * Short for 'Content-Type'
+     *
+     * Available:
+     * - 'none': do not parse body
+     * - 'text' / 'text/plain': parse body as string
+     * - 'json' / 'application/json': parse body as json
+     * - 'formdata' / 'multipart/form-data': parse body as form-data
+     * - 'urlencoded' / 'application/x-www-form-urlencoded: parse body as urlencoded
+     * - 'arraybuffer': parse body as readable stream
+     */
+    type?: ContentType;
+    detail?: DocumentDecoration;
+};
+export type ComposedHandler = (context: Context) => MaybePromise<Response>;
+export interface InternalRoute {
+    method: HTTPMethod;
+    path: string;
+    composed: ComposedHandler | Response | null;
+    handler: Handler;
+    hooks: LocalHook<any, any, any, any, any, any, any>;
+}
+export type ListenCallback = (server: Server) => MaybePromise<void>;
+export type AddPrefix<Prefix extends string, T> = {
+    [K in keyof T as Prefix extends string ? `${Prefix}${K & string}` : K]: T[K];
+};
+export type AddPrefixCapitalize<Prefix extends string, T> = {
+    [K in keyof T as `${Prefix}${Capitalize<K & string>}`]: T[K];
+};
+export type AddSuffix<Suffix extends string, T> = {
+    [K in keyof T as `${K & string}${Suffix}`]: T[K];
+};
+export type AddSuffixCapitalize<Suffix extends string, T> = {
+    [K in keyof T as `${K & string}${Capitalize<Suffix>}`]: T[K];
+};
+export type Checksum = {
+    name?: string;
+    seed?: unknown;
+    checksum: number;
+    stack?: string;
+    routes?: InternalRoute[];
+    decorators?: SingletonBase['decorator'];
+    store?: SingletonBase['store'];
+    type?: DefinitionBase['type'];
+    error?: DefinitionBase['error'];
+    dependencies?: Record<string, Checksum[]>;
+    derive?: {
+        fn: string;
+        stack: string;
+    }[];
+    resolve?: {
+        fn: string;
+        stack: string;
+    }[];
+};
+export type BaseMacro = Record<string, string | number | boolean | Object | undefined | null>;
+export type BaseMacroFn = Record<string, (...a: any) => unknown>;
+export type MacroToProperty<in out T extends BaseMacroFn> = Prettify<{
+    [K in keyof T]: T[K] extends Function ? T[K] extends (a: infer Params) => any ? Params | undefined : T[K] : T[K];
+}>;
+interface MacroOptions {
+    insert?: 'before' | 'after';
+    stack?: 'global' | 'local';
+}
+export interface MacroManager<in out TypedRoute extends RouteSchema = {}, in out Singleton extends SingletonBase = {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, in out Errors extends Record<string, Error> = {}> {
+    onParse(fn: MaybeArray<BodyHandler<TypedRoute, Singleton>>): unknown;
+    onParse(options: MacroOptions, fn: MaybeArray<BodyHandler<TypedRoute, Singleton>>): unknown;
+    onTransform(fn: MaybeArray<VoidHandler<TypedRoute, Singleton>>): unknown;
+    onTransform(options: MacroOptions, fn: MaybeArray<VoidHandler<TypedRoute, Singleton>>): unknown;
+    onBeforeHandle(fn: MaybeArray<OptionalHandler<TypedRoute, Singleton>>): unknown;
+    onBeforeHandle(options: MacroOptions, fn: MaybeArray<OptionalHandler<TypedRoute, Singleton>>): unknown;
+    onAfterHandle(fn: MaybeArray<AfterHandler<TypedRoute, Singleton>>): unknown;
+    onAfterHandle(options: MacroOptions, fn: MaybeArray<AfterHandler<TypedRoute, Singleton>>): unknown;
+    onError(fn: MaybeArray<ErrorHandler<Errors, TypedRoute, Singleton>>): unknown;
+    onError(options: MacroOptions, fn: MaybeArray<ErrorHandler<Errors, TypedRoute, Singleton>>): unknown;
+    mapResponse(fn: MaybeArray<MapResponse<TypedRoute, Singleton>>): unknown;
+    mapResponse(options: MacroOptions, fn: MaybeArray<MapResponse<TypedRoute, Singleton>>): unknown;
+    onAfterResponse(fn: MaybeArray<AfterResponseHandler<TypedRoute, Singleton>>): unknown;
+    onAfterResponse(options: MacroOptions, fn: MaybeArray<AfterResponseHandler<TypedRoute, Singleton>>): unknown;
+    events: {
+        global: Prettify<LifeCycleStore & RouteSchema>;
+        local: Prettify<LifeCycleStore & RouteSchema>;
+    };
+}
+export type MacroQueue = HookContainer<(manager: MacroManager<any, any, any>) => unknown>;
+type _CreateEden<Path extends string, Property extends Record<string, unknown> = {}> = Path extends `${infer Start}/${infer Rest}` ? {
+    [x in Start]: _CreateEden<Rest, Property>;
+} : {
+    [x in Path]: Property;
+};
+export type CreateEden<Path extends string, Property extends Record<string, unknown> = {}> = Path extends `/${infer Rest}` ? _CreateEden<Rest, Property> : Path extends '' ? _CreateEden<'index', Property> : _CreateEden<Path, Property>;
+export type ComposeElysiaResponse<Response, Handle> = Handle extends (...a: any[]) => infer A ? _ComposeElysiaResponse<Response, Replace<Awaited<A>, BunFile, File>> : _ComposeElysiaResponse<Response, Replace<Awaited<Handle>, BunFile, File>>;
+type _ComposeElysiaResponse<Response, Handle> = Prettify<{} extends Response ? {
+    200: Exclude<Handle, {
+        [ELYSIA_RESPONSE]: any;
+    }>;
+} & {
+    [ErrorResponse in Extract<Handle, {
+        response: any;
+    }> as ErrorResponse extends {
+        [ELYSIA_RESPONSE]: infer Status extends number;
+    } ? Status : never]: ErrorResponse['response'];
+} : Response>;
+export type MergeElysiaInstances<Instances extends Elysia<any, any, any, any, any, any>[] = [], Prefix extends string = '', Scoped extends boolean = false, Singleton extends SingletonBase = {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, Definitions extends DefinitionBase = {
+    type: {};
+    error: {};
+}, Metadata extends MetadataBase = {
+    schema: {};
+    macro: {};
+    macroFn: {};
+}, Routes extends RouteBase = {}> = Instances extends [
+    infer Current extends Elysia<any, any, any, any, any, any>,
+    ...infer Rest extends Elysia<any, any, any, any, any, any>[]
+] ? Current['_types']['Scoped'] extends true ? MergeElysiaInstances<Rest, Prefix, Scoped, Singleton, Definitions, Metadata, Routes> : MergeElysiaInstances<Rest, Prefix, Scoped, Singleton & Current['_types']['Singleton'], Definitions & Current['_types']['Definitions'], Metadata & Current['_types']['Metadata'], Routes & (Prefix extends `` ? Current['_routes'] : AddPrefix<Prefix, Current['_routes']>)> : Elysia<Prefix, Scoped, {
+    decorator: Prettify<Singleton['decorator']>;
+    store: Prettify<Singleton['store']>;
+    derive: Prettify<Singleton['derive']>;
+    resolve: Prettify<Singleton['resolve']>;
+}, {
+    type: Prettify<Definitions['type']>;
+    error: Prettify<Definitions['error']>;
+}, {
+    schema: Prettify<Metadata['schema']>;
+    macro: Prettify<Metadata['macro']>;
+    macroFn: Prettify<Metadata['macroFn']>;
+}, Routes>;
+export type LifeCycleType = 'global' | 'local' | 'scoped';
+export type ExcludeElysiaResponse<T> = Exclude<undefined extends Awaited<T> ? Partial<Awaited<T>> : Awaited<T>, {
+    [ELYSIA_RESPONSE]: any;
+}>;
+export type InferContext<T extends Elysia<any, any, any, any, any, any, any, any>, Path extends string = T['_types']['Prefix'], Schema extends RouteSchema = T['_types']['Metadata']['schema']> = Context<MergeSchema<Schema, T['_types']['Metadata']['schema']>, T['_types']['Singleton'] & {
+    derive: T['_ephemeral']['derive'] & T['_volatile']['derive'];
+    resolve: T['_ephemeral']['resolve'] & T['_volatile']['resolve'];
+}, Path>;
+export type InferHandler<T extends Elysia<any, any, any, any, any, any, any, any>, Path extends string = T['_types']['Prefix'], Schema extends RouteSchema = T['_types']['Metadata']['schema']> = InlineHandler<MergeSchema<Schema, T['_types']['Metadata']['schema']>, T['_types']['Singleton'] & {
+    derive: T['_ephemeral']['derive'] & T['_volatile']['derive'];
+    resolve: T['_ephemeral']['resolve'] & T['_volatile']['resolve'];
+}, Path>;
+export interface ModelValidatorError extends ValueError {
+    summary: string;
+}
+export interface ModelValidator<T> extends TypeCheck<T> {
+    parse(a: T): T;
+    safeParse(a: T): {
+        success: true;
+        data: T;
+        error: null;
+    } | {
+        success: true;
+        data: null;
+        error: string;
+        errors: ModelValidatorError[];
+    };
+}
+export type UnionToIntersect<U> = (U extends unknown ? (arg: U) => 0 : never) extends (arg: infer I) => 0 ? I : never;
+export type ResolveMacroContext<Macro extends BaseMacro, MacroFn extends BaseMacroFn> = UnionToIntersect<{
+    [K in keyof Macro]-?: undefined extends Macro[K] ? never : K extends keyof MacroFn ? ReturnType<MacroFn[K]> extends infer A extends Record<string | number | symbol, unknown> ? A : never : never;
+}[keyof Macro]>;
+export type ContextAppendType = 'append' | 'override';
+export type HigherOrderFunction<T extends (...arg: unknown[]) => Function = (...arg: unknown[]) => Function> = (fn: T, request: Request) => ReturnType<T>;
+export type HTTPHeaders = Record<string, string> & {
+    'www-authenticate'?: string;
+    authorization?: string;
+    'proxy-authenticate'?: string;
+    'proxy-authorization'?: string;
+    age?: string;
+    'cache-control'?: string;
+    'clear-site-data'?: string;
+    expires?: string;
+    'no-vary-search'?: string;
+    pragma?: string;
+    'last-modified'?: string;
+    etag?: string;
+    'if-match'?: string;
+    'if-none-match'?: string;
+    'if-modified-since'?: string;
+    'if-unmodified-since'?: string;
+    vary?: string;
+    connection?: string;
+    'keep-alive'?: string;
+    accept?: string;
+    'accept-encoding'?: string;
+    'accept-language'?: string;
+    expect?: string;
+    'max-forwards'?: string;
+    cookie?: string;
+    'set-cookie'?: string | string[];
+    'access-control-allow-origin'?: string;
+    'access-control-allow-credentials'?: string;
+    'access-control-allow-headers'?: string;
+    'access-control-allow-methods'?: string;
+    'access-control-expose-headers'?: string;
+    'access-control-max-age'?: string;
+    'access-control-request-headers'?: string;
+    'access-control-request-method'?: string;
+    origin?: string;
+    'timing-allow-origin'?: string;
+    'content-disposition'?: string;
+    'content-length'?: string;
+    'content-type'?: string;
+    'content-encoding'?: string;
+    'content-language'?: string;
+    'content-location'?: string;
+    forwarded?: string;
+    via?: string;
+    location?: string;
+    refresh?: string;
+    allow?: string;
+    server?: 'Elysia' | (string & {});
+    'accept-ranges'?: string;
+    range?: string;
+    'if-range'?: string;
+    'content-range'?: string;
+    'content-security-policy'?: string;
+    'content-security-policy-report-only'?: string;
+    'cross-origin-embedder-policy'?: string;
+    'cross-origin-opener-policy'?: string;
+    'cross-origin-resource-policy'?: string;
+    'expect-ct'?: string;
+    'permission-policy'?: string;
+    'strict-transport-security'?: string;
+    'upgrade-insecure-requests'?: string;
+    'x-content-type-options'?: string;
+    'x-frame-options'?: string;
+    'x-xss-protection'?: string;
+    'last-event-id'?: string;
+    'ping-from'?: string;
+    'ping-to'?: string;
+    'report-to'?: string;
+    te?: string;
+    trailer?: string;
+    'transfer-encoding'?: string;
+    'alt-svg'?: string;
+    'alt-used'?: string;
+    date?: string;
+    dnt?: string;
+    'early-data'?: string;
+    'large-allocation'?: string;
+    link?: string;
+    'retry-after'?: string;
+    'service-worker-allowed'?: string;
+    'source-map'?: string;
+    upgrade?: string;
+    'x-dns-prefetch-control'?: string;
+    'x-forwarded-for'?: string;
+    'x-forwarded-host'?: string;
+    'x-forwarded-proto'?: string;
+    'x-powered-by'?: 'Elysia' | (string & {});
+    'x-request-id'?: string;
+    'x-requested-with'?: string;
+    'x-robots-tag'?: string;
+    'x-ua-compatible'?: string;
+};
+export type JoinPath<A extends string, B extends string> = `${A}${B extends '/' ? '/index' : B extends '' ? B : B extends `/${string}` ? B : B}`;
+export {};
+//# sourceMappingURL=types.d.ts.map