@axeom/core 0.1.1

package/dist/index.d.cts

@@ -0,0 +1,291 @@
+import { Logger } from '@axeom/logger-lib';
+
+/**
+ * Base error class for all Axeom-related failures.
+ * These are automatically caught and converted into structured JSON responses.
+ */
+declare class AxeomError extends Error {
+    message: string;
+    status: number;
+    code: string;
+    details?: any | undefined;
+    constructor(message: string, status?: number, code?: string, details?: any | undefined);
+}
+declare class NotFoundError extends AxeomError {
+    constructor(message?: string, details?: any);
+}
+declare class UnauthorizedError extends AxeomError {
+    constructor(message?: string, details?: any);
+}
+declare class BadRequestError extends AxeomError {
+    constructor(message?: string, details?: any);
+}
+declare class ForbiddenError extends AxeomError {
+    constructor(message?: string, details?: any);
+}
+declare class InternalServerError extends AxeomError {
+    constructor(message?: string);
+}
+declare class ConflictError extends AxeomError {
+    constructor(message?: string, details?: any);
+}
+
+type ExtractParams<T> = T extends `${string}/:${infer P}/${infer Rest}` ? P | ExtractParams<`/${Rest}`> : T extends `${string}/:${infer P}` ? P : never;
+type ParamsObject<T extends string> = {
+    [K in ExtractParams<T>]: string;
+};
+type Prettify<T> = T extends Function | any[] ? T : {
+    [K in keyof T]: T[K] extends object ? Prettify<T[K]> : T[K];
+} & {};
+/**
+ * Contract for schema validation. Implementing this allows custom object types
+ * to be used in RouteSchema.
+ */
+interface Validator<T = any> {
+    _output: T;
+    parse: (data: unknown) => T | Promise<T>;
+}
+/**
+ * Defines the validation structure for a route's parameters, query, and body.
+ */
+type RouteSchema = {
+    body?: Validator;
+    query?: Validator;
+    params?: Validator;
+    responses?: Record<number, any>;
+    summary?: string;
+    description?: string;
+    tags?: string[];
+};
+type Infer<S> = S extends Validator<infer T> ? T : any;
+type RouteInput<Path extends string, S extends RouteSchema> = Prettify<(S["body"] extends Validator ? {
+    body: Infer<S["body"]>;
+} : {
+    body?: never;
+}) & (S["query"] extends Validator ? {
+    query: Infer<S["query"]>;
+} : {
+    query?: Record<string, string | undefined>;
+}) & (keyof ParamsObject<Path> extends never ? {
+    params?: ParamsObject<Path>;
+} : {
+    params: ParamsObject<Path>;
+})>;
+type RouteMetadata<Path extends string, S extends RouteSchema, Return> = {
+    input: RouteInput<Path, S>;
+    output: Return;
+};
+/**
+ * Automatically prefixes all keys in a metadata object (e.g., "GET /users" -> "GET /v1/users")
+ */
+type PrefixT<Prefix extends string, T> = {
+    [K in keyof T as K extends `${infer Method} ${infer Path}` ? `${Method} ${Prefix}${Path}` extends `${infer M} ${infer P}` ? `${M} ${P extends `/${string}` ? P : `/${P}`}` : never : never]: T[K];
+};
+/**
+ * The request context passed to every route handler.
+ * Provides access to parsed body, query, params, and decorators.
+ */
+type Context<Path extends string, S extends RouteSchema = {}, T extends Record<string, any> = {}, D extends Record<string, any> = {}> = Prettify<{
+    /** The URL path parameters. */
+    params: S["params"] extends Validator ? Infer<S["params"]> : ParamsObject<Path>;
+    /** The URL search parameters. */
+    query: S["query"] extends Validator ? Infer<S["query"]> : Record<string, string | undefined>;
+    /** The parsed request body. */
+    body: S["body"] extends Validator ? Infer<S["body"]> : any;
+    /** Standard Web Headers object. */
+    headers: Headers;
+    /** The original Web Request object. */
+    request: Request;
+    /** The start time of the request in milliseconds. */
+    time: number;
+    /** Marks the duration for a specific label, returning the elapsed time since start. */
+    setDuration: (label: string) => number;
+    /** Helper to set a response header. */
+    setResponseHeader: (name: string, value: string) => void;
+    /** Internal helper to retrieve manual headers. */
+    getResponseHeaders: () => Record<string, string>;
+} & T & D>;
+/**
+ * A function that handles an incoming request for a specific route.
+ */
+type Handler<Path extends string = string, S extends RouteSchema = {}, T extends Record<string, any> = {}, D extends Record<string, any> = {}, Return = any> = (ctx: Context<Path, S, T, D>) => Return | Promise<Return>;
+interface Route<T extends Record<string, any> = any, D extends Record<string, any> = any> {
+    method: string;
+    path: string;
+    regex: RegExp;
+    handler: Handler<any, any, T, D, any>;
+    paramNames: string[];
+    schema?: RouteSchema;
+    derives: Array<(ctx: any) => any>;
+    decorators: Record<string, any>;
+    onRequests?: Array<(ctx: any) => void | Promise<void>>;
+    onResponses?: Array<(res: Response, ctx: any) => Response | void | undefined | Promise<Response | void | undefined>>;
+    beforeHandles: Array<(ctx: Context<any, any, T, D>) => Response | void | undefined | Promise<Response | void | undefined>>;
+    afterHandles: Array<(ctx: Context<any, any, T, D>) => Response | void | undefined | Promise<Response | void | undefined>>;
+    metadata?: Record<string, any>;
+}
+
+/**
+ * Manages route registration and path matching using a Radix Tree.
+ */
+declare class Router<T extends Record<string, any>, D extends Record<string, any>> {
+    private tree;
+    private routes;
+    /**
+     * Registers a new route with its associated state (hooks, derivations, and decorators).
+     */
+    add<Path extends string, S extends RouteSchema, Return>(method: string, path: Path, handler: Handler<Path, S, T, D, Return>, state: {
+        derives: any[];
+        decorators: any;
+        onRequests: any[];
+        onResponses: any[];
+        beforeHandles: any[];
+        afterHandles: any[];
+    }, schema?: S, metadata?: Record<string, any>): Route<T, D>;
+    /**
+     * Finds a matching route for the given method and pathname.
+     */
+    match(method: string, pathname: string): {
+        route: Route<T, D>;
+        match: string[];
+    } | null;
+    addRoute(route: Route<T, D>): void;
+    getRoutes(): Route<T, D>[];
+    setRoutes(routes: Route<T, D>[]): void;
+}
+
+/**
+ * Internal symbol used to store the server instance in the context.
+ */
+declare const $SERVER: unique symbol;
+/**
+ * The primary engine of the Axeom framework.
+ *
+ * Axeom is a WinterTC-compliant, type-safe web framework designed for high-performance
+ * and modularity. It supports automatic runtime detection (Bun, Deno, Node) and
+ * provides a powerful plugin system.
+ *
+ * @template T - A record of route strings to their respective metadata, used for type-safe client generation.
+ * @template D - A record of objects and utilities available on the request context (decorators).
+ */
+declare class Axeom<T extends Record<string, any> = {}, D extends Record<string, any> = {
+    logger: Logger;
+    error: {
+        NotFound: (msg?: string) => NotFoundError;
+        Unauthorized: (msg?: string) => UnauthorizedError;
+        BadRequest: (msg?: string) => BadRequestError;
+        Forbidden: (msg?: string) => ForbiddenError;
+        Conflict: (msg?: string) => ConflictError;
+    };
+}> {
+    router: Router<T, D>;
+    private hooks;
+    private server;
+    private derives;
+    private decorators;
+    private errorHandler;
+    /**
+     * Adds dynamic properties to the context by running a function before the route handler.
+     * Derivations can be asynchronous and can return a Response to short-circuit the request.
+     *
+     * @param fn - A function that receives the current context and returns new properties to merge.
+     */
+    derive<NewD extends Record<string, any>>(fn: (ctx: Context<any, any, T, D>) => NewD | Response | Promise<NewD | Response>): Axeom<T, D & Exclude<NewD, Response>>;
+    /**
+     * Registers a plugin.
+     * Plugins are functions that receive the Axeom instance and can register routes,
+     * hooks, or decorators.
+     *
+     * @param plugin - The plugin function to execute.
+     */
+    use<NewT extends Record<string, any>, NewD extends Record<string, any>>(plugin: (app: Axeom<T, D>) => Axeom<NewT, NewD>): Axeom<T & NewT, NewD>;
+    /**
+     * Groups routes under a common path prefix.
+     * This provides isolation for derivations and hooks within the group.
+     *
+     * @param prefix - The path prefix (e.g., "/api/v1").
+     * @param run - A function where you define the routes for this group.
+     */
+    group<Prefix extends string, NewT extends Record<string, any>, NewD extends Record<string, any>>(prefix: Prefix, run: (app: Axeom<T, D>) => Axeom<NewT, NewD>): Axeom<T & PrefixT<Prefix, NewT>, NewD>;
+    /**
+     * Adds static properties to the context.
+     * Decorators are available on every request context immediately.
+     *
+     * @param obj - An object containing properties to add to the context.
+     */
+    decorate<NewD extends Record<string, any>>(obj: NewD): Axeom<T, D & NewD>;
+    protected addRoute<Method extends string, Path extends string, S extends RouteSchema = {}, Return = any>(method: Method, path: Path, handler: Handler<Path, S, T, D, Return>, schema?: S, metadata?: Record<string, any>): Axeom<T & { [K in `${Method} ${Path}`]: RouteMetadata<Path, S, Return>; }, D>;
+    get<Path extends string, S extends RouteSchema = {}, Return = any>(path: Path, handler: Handler<Path, S, T, D, Return>, schema?: S): Axeom<T & { [K in `GET ${Path}`]: RouteMetadata<Path, S, Return>; }, D>;
+    post<Path extends string, S extends RouteSchema = {}, Return = any>(path: Path, handler: Handler<Path, S, T, D, Return>, schema?: S): Axeom<T & { [K in `POST ${Path}`]: RouteMetadata<Path, S, Return>; }, D>;
+    put<Path extends string, S extends RouteSchema = {}, Return = any>(path: Path, handler: Handler<Path, S, T, D, Return>, schema?: S): Axeom<T & { [K in `PUT ${Path}`]: RouteMetadata<Path, S, Return>; }, D>;
+    patch<Path extends string, S extends RouteSchema = {}, Return = any>(path: Path, handler: Handler<Path, S, T, D, Return>, schema?: S): Axeom<T & { [K in `PATCH ${Path}`]: RouteMetadata<Path, S, Return>; }, D>;
+    delete<Path extends string, S extends RouteSchema = {}, Return = any>(path: Path, handler: Handler<Path, S, T, D, Return>, schema?: S): Axeom<T & { [K in `DELETE ${Path}`]: RouteMetadata<Path, S, Return>; }, D>;
+    /**
+     * Main entry point for handling requests.
+     *
+     * This is the standard WinterTC interface that converts a Request into a Response.
+     * It executes the entire request lifecycle including hooks, derivations, and validation.
+     *
+     * @param incomingRequest - The standard Web Request object.
+     * @param options - Optional runtime configuration (e.g. server instance).
+     * @returns A promise resolving to a standard Web Response object.
+     */
+    handle(incomingRequest: Request, options?: {
+        server?: any;
+    }): Promise<Response>;
+    /**
+     * Internal method used by adapters to handle both HTTP and WebSocket handshakes.
+     * Returns the final response and the context used for the request.
+     */
+    _handleHandshake(incomingRequest: Request, options?: {
+        server?: any;
+    }): Promise<{
+        response: Response;
+        context?: any;
+    }>;
+    /**
+     * Registers a global error handler.
+     */
+    onError(fn: (error: any, ctx: Context<any, any, T, D>) => any): this;
+    /**
+     * Registers a global hook that runs as soon as a request is received.
+     */
+    onRequest(fn: (ctx: Context<any, any, T, D>) => void | Promise<void>): this;
+    /**
+     * Registers a hook that runs before the router attempts to match a path.
+     * Useful for global redirects or early security checks.
+     */
+    onBeforeMatch(fn: (req: Request) => Response | void | undefined | Promise<Response | void | undefined>): this;
+    /**
+     * Registers a global hook that runs after a Response has been created.
+     * Allows modifying headers or the body before it's sent.
+     */
+    onResponse(fn: (res: Response, ctx: Context<any, any, T, D>) => Response | void | undefined | Promise<Response | void | undefined>): this;
+    /**
+     * Registers a hook that runs before the route handler is executed.
+     */
+    onBeforeHandle(fn: (ctx: Context<any, any, T, D>) => Response | void | undefined | Promise<Response | void | undefined>): this;
+    /**
+     * Registers a hook that runs after the route handler is executed.
+     */
+    onAfterHandle(fn: (ctx: Context<any, any, T, D>) => Response | void | undefined | Promise<Response | void | undefined>): this;
+    /**
+     * Registers a Server-Sent Events (SSE) route.
+     *
+     * @param path - The path for the SSE stream.
+     * @param handler - A function returning an async iterable that yields data chunks.
+     */
+    sse<T = any>(path: string, handler: (ctx: any) => AsyncIterable<T> | Promise<AsyncIterable<T>>): Axeom<T_1 & {
+        [x: `GET ${string}`]: RouteMetadata<string, {}, Response>;
+    }, D>;
+    /**
+     * Automatically detect the runtime and start a server.
+     * Currently supports: Bun, Deno.
+     * For Node, use a specific adapter like @axeom/express.
+     *
+     * @param portOrOptions - The port number or a server options object.
+     */
+    listen(portOrOptions?: number | any): any;
+}
+
+export { $SERVER, Axeom, AxeomError, BadRequestError, ConflictError, type Context, type ExtractParams, ForbiddenError, type Handler, type Infer, InternalServerError, NotFoundError, type ParamsObject, type PrefixT, type Prettify, type Route, type RouteInput, type RouteMetadata, type RouteSchema, UnauthorizedError, type Validator, Axeom as default };

package/dist/index.d.ts

@@ -0,0 +1,291 @@
+import { Logger } from '@axeom/logger-lib';
+
+/**
+ * Base error class for all Axeom-related failures.
+ * These are automatically caught and converted into structured JSON responses.
+ */
+declare class AxeomError extends Error {
+    message: string;
+    status: number;
+    code: string;
+    details?: any | undefined;
+    constructor(message: string, status?: number, code?: string, details?: any | undefined);
+}
+declare class NotFoundError extends AxeomError {
+    constructor(message?: string, details?: any);
+}
+declare class UnauthorizedError extends AxeomError {
+    constructor(message?: string, details?: any);
+}
+declare class BadRequestError extends AxeomError {
+    constructor(message?: string, details?: any);
+}
+declare class ForbiddenError extends AxeomError {
+    constructor(message?: string, details?: any);
+}
+declare class InternalServerError extends AxeomError {
+    constructor(message?: string);
+}
+declare class ConflictError extends AxeomError {
+    constructor(message?: string, details?: any);
+}
+
+type ExtractParams<T> = T extends `${string}/:${infer P}/${infer Rest}` ? P | ExtractParams<`/${Rest}`> : T extends `${string}/:${infer P}` ? P : never;
+type ParamsObject<T extends string> = {
+    [K in ExtractParams<T>]: string;
+};
+type Prettify<T> = T extends Function | any[] ? T : {
+    [K in keyof T]: T[K] extends object ? Prettify<T[K]> : T[K];
+} & {};
+/**
+ * Contract for schema validation. Implementing this allows custom object types
+ * to be used in RouteSchema.
+ */
+interface Validator<T = any> {
+    _output: T;
+    parse: (data: unknown) => T | Promise<T>;
+}
+/**
+ * Defines the validation structure for a route's parameters, query, and body.
+ */
+type RouteSchema = {
+    body?: Validator;
+    query?: Validator;
+    params?: Validator;
+    responses?: Record<number, any>;
+    summary?: string;
+    description?: string;
+    tags?: string[];
+};
+type Infer<S> = S extends Validator<infer T> ? T : any;
+type RouteInput<Path extends string, S extends RouteSchema> = Prettify<(S["body"] extends Validator ? {
+    body: Infer<S["body"]>;
+} : {
+    body?: never;
+}) & (S["query"] extends Validator ? {
+    query: Infer<S["query"]>;
+} : {
+    query?: Record<string, string | undefined>;
+}) & (keyof ParamsObject<Path> extends never ? {
+    params?: ParamsObject<Path>;
+} : {
+    params: ParamsObject<Path>;
+})>;
+type RouteMetadata<Path extends string, S extends RouteSchema, Return> = {
+    input: RouteInput<Path, S>;
+    output: Return;
+};
+/**
+ * Automatically prefixes all keys in a metadata object (e.g., "GET /users" -> "GET /v1/users")
+ */
+type PrefixT<Prefix extends string, T> = {
+    [K in keyof T as K extends `${infer Method} ${infer Path}` ? `${Method} ${Prefix}${Path}` extends `${infer M} ${infer P}` ? `${M} ${P extends `/${string}` ? P : `/${P}`}` : never : never]: T[K];
+};
+/**
+ * The request context passed to every route handler.
+ * Provides access to parsed body, query, params, and decorators.
+ */
+type Context<Path extends string, S extends RouteSchema = {}, T extends Record<string, any> = {}, D extends Record<string, any> = {}> = Prettify<{
+    /** The URL path parameters. */
+    params: S["params"] extends Validator ? Infer<S["params"]> : ParamsObject<Path>;
+    /** The URL search parameters. */
+    query: S["query"] extends Validator ? Infer<S["query"]> : Record<string, string | undefined>;
+    /** The parsed request body. */
+    body: S["body"] extends Validator ? Infer<S["body"]> : any;
+    /** Standard Web Headers object. */
+    headers: Headers;
+    /** The original Web Request object. */
+    request: Request;
+    /** The start time of the request in milliseconds. */
+    time: number;
+    /** Marks the duration for a specific label, returning the elapsed time since start. */
+    setDuration: (label: string) => number;
+    /** Helper to set a response header. */
+    setResponseHeader: (name: string, value: string) => void;
+    /** Internal helper to retrieve manual headers. */
+    getResponseHeaders: () => Record<string, string>;
+} & T & D>;
+/**
+ * A function that handles an incoming request for a specific route.
+ */
+type Handler<Path extends string = string, S extends RouteSchema = {}, T extends Record<string, any> = {}, D extends Record<string, any> = {}, Return = any> = (ctx: Context<Path, S, T, D>) => Return | Promise<Return>;
+interface Route<T extends Record<string, any> = any, D extends Record<string, any> = any> {
+    method: string;
+    path: string;
+    regex: RegExp;
+    handler: Handler<any, any, T, D, any>;
+    paramNames: string[];
+    schema?: RouteSchema;
+    derives: Array<(ctx: any) => any>;
+    decorators: Record<string, any>;
+    onRequests?: Array<(ctx: any) => void | Promise<void>>;
+    onResponses?: Array<(res: Response, ctx: any) => Response | void | undefined | Promise<Response | void | undefined>>;
+    beforeHandles: Array<(ctx: Context<any, any, T, D>) => Response | void | undefined | Promise<Response | void | undefined>>;
+    afterHandles: Array<(ctx: Context<any, any, T, D>) => Response | void | undefined | Promise<Response | void | undefined>>;
+    metadata?: Record<string, any>;
+}
+
+/**
+ * Manages route registration and path matching using a Radix Tree.
+ */
+declare class Router<T extends Record<string, any>, D extends Record<string, any>> {
+    private tree;
+    private routes;
+    /**
+     * Registers a new route with its associated state (hooks, derivations, and decorators).
+     */
+    add<Path extends string, S extends RouteSchema, Return>(method: string, path: Path, handler: Handler<Path, S, T, D, Return>, state: {
+        derives: any[];
+        decorators: any;
+        onRequests: any[];
+        onResponses: any[];
+        beforeHandles: any[];
+        afterHandles: any[];
+    }, schema?: S, metadata?: Record<string, any>): Route<T, D>;
+    /**
+     * Finds a matching route for the given method and pathname.
+     */
+    match(method: string, pathname: string): {
+        route: Route<T, D>;
+        match: string[];
+    } | null;
+    addRoute(route: Route<T, D>): void;
+    getRoutes(): Route<T, D>[];
+    setRoutes(routes: Route<T, D>[]): void;
+}
+
+/**
+ * Internal symbol used to store the server instance in the context.
+ */
+declare const $SERVER: unique symbol;
+/**
+ * The primary engine of the Axeom framework.
+ *
+ * Axeom is a WinterTC-compliant, type-safe web framework designed for high-performance
+ * and modularity. It supports automatic runtime detection (Bun, Deno, Node) and
+ * provides a powerful plugin system.
+ *
+ * @template T - A record of route strings to their respective metadata, used for type-safe client generation.
+ * @template D - A record of objects and utilities available on the request context (decorators).
+ */
+declare class Axeom<T extends Record<string, any> = {}, D extends Record<string, any> = {
+    logger: Logger;
+    error: {
+        NotFound: (msg?: string) => NotFoundError;
+        Unauthorized: (msg?: string) => UnauthorizedError;
+        BadRequest: (msg?: string) => BadRequestError;
+        Forbidden: (msg?: string) => ForbiddenError;
+        Conflict: (msg?: string) => ConflictError;
+    };
+}> {
+    router: Router<T, D>;
+    private hooks;
+    private server;
+    private derives;
+    private decorators;
+    private errorHandler;
+    /**
+     * Adds dynamic properties to the context by running a function before the route handler.
+     * Derivations can be asynchronous and can return a Response to short-circuit the request.
+     *
+     * @param fn - A function that receives the current context and returns new properties to merge.
+     */
+    derive<NewD extends Record<string, any>>(fn: (ctx: Context<any, any, T, D>) => NewD | Response | Promise<NewD | Response>): Axeom<T, D & Exclude<NewD, Response>>;
+    /**
+     * Registers a plugin.
+     * Plugins are functions that receive the Axeom instance and can register routes,
+     * hooks, or decorators.
+     *
+     * @param plugin - The plugin function to execute.
+     */
+    use<NewT extends Record<string, any>, NewD extends Record<string, any>>(plugin: (app: Axeom<T, D>) => Axeom<NewT, NewD>): Axeom<T & NewT, NewD>;
+    /**
+     * Groups routes under a common path prefix.
+     * This provides isolation for derivations and hooks within the group.
+     *
+     * @param prefix - The path prefix (e.g., "/api/v1").
+     * @param run - A function where you define the routes for this group.
+     */
+    group<Prefix extends string, NewT extends Record<string, any>, NewD extends Record<string, any>>(prefix: Prefix, run: (app: Axeom<T, D>) => Axeom<NewT, NewD>): Axeom<T & PrefixT<Prefix, NewT>, NewD>;
+    /**
+     * Adds static properties to the context.
+     * Decorators are available on every request context immediately.
+     *
+     * @param obj - An object containing properties to add to the context.
+     */
+    decorate<NewD extends Record<string, any>>(obj: NewD): Axeom<T, D & NewD>;
+    protected addRoute<Method extends string, Path extends string, S extends RouteSchema = {}, Return = any>(method: Method, path: Path, handler: Handler<Path, S, T, D, Return>, schema?: S, metadata?: Record<string, any>): Axeom<T & { [K in `${Method} ${Path}`]: RouteMetadata<Path, S, Return>; }, D>;
+    get<Path extends string, S extends RouteSchema = {}, Return = any>(path: Path, handler: Handler<Path, S, T, D, Return>, schema?: S): Axeom<T & { [K in `GET ${Path}`]: RouteMetadata<Path, S, Return>; }, D>;
+    post<Path extends string, S extends RouteSchema = {}, Return = any>(path: Path, handler: Handler<Path, S, T, D, Return>, schema?: S): Axeom<T & { [K in `POST ${Path}`]: RouteMetadata<Path, S, Return>; }, D>;
+    put<Path extends string, S extends RouteSchema = {}, Return = any>(path: Path, handler: Handler<Path, S, T, D, Return>, schema?: S): Axeom<T & { [K in `PUT ${Path}`]: RouteMetadata<Path, S, Return>; }, D>;
+    patch<Path extends string, S extends RouteSchema = {}, Return = any>(path: Path, handler: Handler<Path, S, T, D, Return>, schema?: S): Axeom<T & { [K in `PATCH ${Path}`]: RouteMetadata<Path, S, Return>; }, D>;
+    delete<Path extends string, S extends RouteSchema = {}, Return = any>(path: Path, handler: Handler<Path, S, T, D, Return>, schema?: S): Axeom<T & { [K in `DELETE ${Path}`]: RouteMetadata<Path, S, Return>; }, D>;
+    /**
+     * Main entry point for handling requests.
+     *
+     * This is the standard WinterTC interface that converts a Request into a Response.
+     * It executes the entire request lifecycle including hooks, derivations, and validation.
+     *
+     * @param incomingRequest - The standard Web Request object.
+     * @param options - Optional runtime configuration (e.g. server instance).
+     * @returns A promise resolving to a standard Web Response object.
+     */
+    handle(incomingRequest: Request, options?: {
+        server?: any;
+    }): Promise<Response>;
+    /**
+     * Internal method used by adapters to handle both HTTP and WebSocket handshakes.
+     * Returns the final response and the context used for the request.
+     */
+    _handleHandshake(incomingRequest: Request, options?: {
+        server?: any;
+    }): Promise<{
+        response: Response;
+        context?: any;
+    }>;
+    /**
+     * Registers a global error handler.
+     */
+    onError(fn: (error: any, ctx: Context<any, any, T, D>) => any): this;
+    /**
+     * Registers a global hook that runs as soon as a request is received.
+     */
+    onRequest(fn: (ctx: Context<any, any, T, D>) => void | Promise<void>): this;
+    /**
+     * Registers a hook that runs before the router attempts to match a path.
+     * Useful for global redirects or early security checks.
+     */
+    onBeforeMatch(fn: (req: Request) => Response | void | undefined | Promise<Response | void | undefined>): this;
+    /**
+     * Registers a global hook that runs after a Response has been created.
+     * Allows modifying headers or the body before it's sent.
+     */
+    onResponse(fn: (res: Response, ctx: Context<any, any, T, D>) => Response | void | undefined | Promise<Response | void | undefined>): this;
+    /**
+     * Registers a hook that runs before the route handler is executed.
+     */
+    onBeforeHandle(fn: (ctx: Context<any, any, T, D>) => Response | void | undefined | Promise<Response | void | undefined>): this;
+    /**
+     * Registers a hook that runs after the route handler is executed.
+     */
+    onAfterHandle(fn: (ctx: Context<any, any, T, D>) => Response | void | undefined | Promise<Response | void | undefined>): this;
+    /**
+     * Registers a Server-Sent Events (SSE) route.
+     *
+     * @param path - The path for the SSE stream.
+     * @param handler - A function returning an async iterable that yields data chunks.
+     */
+    sse<T = any>(path: string, handler: (ctx: any) => AsyncIterable<T> | Promise<AsyncIterable<T>>): Axeom<T_1 & {
+        [x: `GET ${string}`]: RouteMetadata<string, {}, Response>;
+    }, D>;
+    /**
+     * Automatically detect the runtime and start a server.
+     * Currently supports: Bun, Deno.
+     * For Node, use a specific adapter like @axeom/express.
+     *
+     * @param portOrOptions - The port number or a server options object.
+     */
+    listen(portOrOptions?: number | any): any;
+}
+
+export { $SERVER, Axeom, AxeomError, BadRequestError, ConflictError, type Context, type ExtractParams, ForbiddenError, type Handler, type Infer, InternalServerError, NotFoundError, type ParamsObject, type PrefixT, type Prettify, type Route, type RouteInput, type RouteMetadata, type RouteSchema, UnauthorizedError, type Validator, Axeom as default };