@ozanarslan/corpus 0.1.4 → 0.1.6

package/dist/index.d.ts

@@ -2,6 +2,14 @@
 
 /// <reference types="node" />
 
+declare abstract class StoreAbstract<T> {
+	protected abstract value: T;
+	set(value: T): void;
+	get(): T;
+}
+declare class GlobalPrefixStore extends StoreAbstract<string> {
+	protected value: string;
+}
 export type CookieOptions = {
 	name: string;
 	value: string;
@@ -62,6 +70,8 @@ export declare const CommonHeaders: {
 	readonly ContentType: "Content-Type";
 	/** Indicates the size of the entity-body in bytes */
 	readonly ContentLength: "Content-Length";
+	/** Whether to display payload inline within the page or prompt the user to download it as an attachment. */
+	readonly ContentDisposition: "Content-Disposition";
 	/** Specifies the character encodings that are acceptable */
 	readonly AcceptEncoding: "Accept-Encoding";
 	/** Informs the server about the types of data that can be sent back */
@@ -106,29 +116,29 @@ export declare const CommonHeaders: {
 };
 export type CommonHeaders = ValueOf<typeof CommonHeaders>;
 export type OrString<T> = T | (string & {});
-type HttpHeaderKey = OrString<CommonHeaders>;
-type HttpHeadersInit = Headers | HttpHeaders | [
+export type HeaderKey = OrString<CommonHeaders>;
+type CHeadersInit = Headers | CHeaders | [
 	string,
 	string
-][] | (Record<string, string> & Partial<Record<HttpHeaderKey, string>>);
+][] | (Record<string, string> & Partial<Record<HeaderKey, string>>);
 /** Headers is extended to include helpers and intellisense for common header names. */
-declare class HttpHeaders extends Headers {
-	constructor(init?: HttpHeadersInit);
-	append(name: HttpHeaderKey, value: string): void;
-	set(name: HttpHeaderKey, value: string): void;
-	get(name: HttpHeaderKey): string | null;
-	has(name: HttpHeaderKey): boolean;
-	delete(name: HttpHeaderKey): void;
-	static combine(source: HttpHeaders, target: HttpHeaders): HttpHeaders;
-	innerCombine(source: HttpHeaders): void;
+declare class CHeaders extends Headers {
+	constructor(init?: CHeadersInit);
+	append(name: HeaderKey, value: string): void;
+	set(name: HeaderKey, value: string): void;
+	get(name: HeaderKey): string | null;
+	has(name: HeaderKey): boolean;
+	delete(name: HeaderKey): void;
+	static combine(source: CHeaders, target: CHeaders): CHeaders;
+	innerCombine(source: CHeaders): void;
 	setMany(init: [
 		string,
 		string
-	][] | (Record<string, string> & Partial<Record<HttpHeaderKey, string>>)): void;
+	][] | (Record<string, string> & Partial<Record<HeaderKey, string>>)): void;
 	/** @deprecated */
-	static findHeaderInInit(init: HttpHeadersInit, name: HttpHeaderKey): string | null;
+	static findHeaderInInit(init: CHeadersInit, name: HeaderKey): string | null;
 }
-type HttpRequestInfo = Request | string | HttpRequest | URL;
+type CRequestInfo = Request | string | CRequest | URL;
 /** Commonly used HTTP verbs. */
 export declare const Method: {
 	readonly GET: "GET";
@@ -142,19 +152,19 @@ export declare const Method: {
 	readonly TRACE: "TRACE";
 };
 export type Method = ValueOf<typeof Method>;
-type HttpRequestInit = Omit<RequestInit, "headers" | "method"> & {
-	headers?: HttpHeadersInit;
+type CRequestInit = Omit<RequestInit, "headers" | "method"> & {
+	headers?: CHeadersInit;
 	method?: Method;
 };
-/** HttpRequest includes a cookie jar, better headers, and some utilities. */
-declare class HttpRequest extends Request {
-	readonly info: HttpRequestInfo;
-	readonly init?: HttpRequestInit | undefined;
-	constructor(info: HttpRequestInfo, init?: HttpRequestInit | undefined);
+/** CRequest includes a cookie jar, better headers, and some utilities. */
+declare class CRequest extends Request {
+	readonly info: CRequestInfo;
+	readonly init?: CRequestInit | undefined;
+	constructor(info: CRequestInfo, init?: CRequestInit | undefined);
 	readonly urlObject: URL;
 	readonly isPreflight: boolean;
 	readonly cookies: Cookies;
-	headers: HttpHeaders;
+	headers: CHeaders;
 	private resolveUrlObject;
 	private resolveHeaders;
 	/** Gets cookie header and collects cookies for the jar */
@@ -295,38 +305,81 @@ export declare const Status: {
 	readonly NETWORK_AUTHENTICATION_REQUIRED: 511;
 };
 export type Status = OrNumber<ValueOf<typeof Status>>;
-type HttpResponseBody<R = unknown> = R | BodyInit | null | undefined;
-type HttpResponseInit = {
+type CResponseBody<R = unknown> = R | BodyInit | null | undefined;
+type CResponseInit = {
 	cookies?: CookiesInit;
-	headers?: HttpHeadersInit;
+	headers?: CHeadersInit;
 	status?: Status;
 	statusText?: string;
 };
+export type SseData = {
+	data: unknown;
+	event?: string;
+	id?: string;
+};
+export type Func<Args extends any[] = any[], Return = any> = (...args: Args) => Return;
+export type SseSource = Func<[
+	send: Func<[
+		event: SseData
+	], void>
+], void | Func<[
+], void>>;
+export type NdjsonSource = Func<[
+	send: Func<[
+		item: unknown
+	], void>
+], void | Func<[
+], void>>;
 /**
- * This is NOT the default response. It provides {@link HttpResponse.response}
- * getter to access web Response with all mutations applied during the
- * handling of the request, JSON body will be handled and cookies will be
- * applied to response headers.
- * */
-declare class HttpResponse<R = unknown> {
-	readonly body?: HttpResponseBody<R>;
-	readonly init?: HttpResponseInit | undefined;
-	constructor(body?: HttpResponseBody<R>, init?: HttpResponseInit | undefined);
-	headers: HttpHeaders;
+ * Represents an HTTP response. Pass it a body and optional init to construct a response,
+ * or use the static methods for common patterns like redirects and streaming.
+ *
+ * The body is automatically serialized based on its type:
+ * - `null` / `undefined` → empty body with `text/plain`
+ * - Primitives (`string`, `number`, `boolean`, `bigint`) → string with `text/plain`
+ * - `Date` → ISO string with `text/plain`
+ * - Plain objects and arrays → JSON string with `application/json`
+ * - `ArrayBuffer` → binary with `application/octet-stream`
+ * - `Blob` → binary with the Blob's own mime type
+ * - `FormData` → multipart with `multipart/form-data`
+ * - `URLSearchParams` → encoded with `application/x-www-form-urlencoded`
+ * - `ReadableStream` → streamed as-is, set `Content-Type` manually via `init.headers`
+ * - Custom class instances → falls back to `.toString()`
+ *
+ * Use {@link CResponse.response} to get the native web `Response` to return from a route handler.
+ *
+ * Static helpers:
+ * - {@link CResponse.redirect} / {@link CResponse.permanentRedirect} / {@link CResponse.temporaryRedirect} / {@link CResponse.seeOther} — HTTP redirects
+ * - {@link CResponse.sse} — Server-Sent Events stream
+ * - {@link CResponse.ndjson} — Newline-delimited JSON stream
+ * - {@link CResponse.streamFile} — Stream a file from disk
+ * - {@link CResponse.file} — Respond with a static file
+ */
+declare class CResponse<R = unknown> {
+	protected readonly data?: CResponseBody<R>;
+	protected readonly init?: CResponseInit | undefined;
+	constructor(data?: CResponseBody<R>, init?: CResponseInit | undefined);
+	body: BodyInit;
+	headers: CHeaders;
 	status: Status;
 	statusText: string;
 	cookies: Cookies;
 	get response(): Response;
-	private getCookies;
-	private getHeaders;
-	private getStatus;
+	static redirect(url: string | URL, init?: CResponseInit): CResponse;
+	static permanentRedirect(url: string | URL, init?: Omit<CResponseInit, "status">): CResponse;
+	static temporaryRedirect(url: string | URL, init?: Omit<CResponseInit, "status">): CResponse;
+	static seeOther(url: string | URL, init?: Omit<CResponseInit, "status">): CResponse;
+	private static createStream;
+	static sse(source: SseSource, init?: Omit<CResponseInit, "status">, retry?: number): CResponse;
+	static ndjson(source: NdjsonSource, init?: Omit<CResponseInit, "status">): CResponse;
+	static streamFile(filePath: string, disposition?: "attachment" | "inline", init?: Omit<CResponseInit, "status">): Promise<CResponse>;
+	static file(filePath: string, init?: CResponseInit): Promise<CResponse>;
+	private resolveCookies;
+	private resolveHeaders;
+	private resolveStatus;
 	private setContentType;
-	private getBody;
+	private resolveBody;
 	private getDefaultStatusText;
-	static redirect(url: string | URL, init?: HttpResponseInit): HttpResponse;
-	static permanentRedirect(url: string | URL, init?: Omit<HttpResponseInit, "status">): HttpResponse;
-	static temporaryRedirect(url: string | URL, init?: Omit<HttpResponseInit, "status">): HttpResponse;
-	static seeOther(url: string | URL, init?: Omit<HttpResponseInit, "status">): HttpResponse;
 }
 declare const RouteVariant: {
 	readonly static: "static";
@@ -491,20 +544,19 @@ export type RouterModelData<B = unknown, S = unknown, P = unknown> = {
  * res = To set the {@link HTTPResponse} data
  * */
 export declare class Context<B = unknown, S = unknown, P = unknown, R = unknown> {
-	constructor(req: HttpRequest, body: B, search: S, params: P, res?: HttpResponse<R>);
-	req: HttpRequest;
+	constructor(req: CRequest, body: B, search: S, params: P, res?: CResponse<R>);
+	req: CRequest;
 	url: URL;
-	headers: HttpHeaders;
+	headers: CHeaders;
 	cookies: Cookies;
 	body: B;
 	search: S;
 	params: P;
-	res: HttpResponse<R>;
+	res: CResponse<R>;
 	data: ContextDataInterface;
-	static makeFromRequest(req: HttpRequest): Context;
-	static appendParsedData<Path extends string = string, B = unknown, S = unknown, P = unknown, R = unknown>(ctx: Context<B, S, P, R>, req: HttpRequest, endpoint: Path, model?: RouterModelData<B, S, P>): Promise<void>;
+	static makeFromRequest(req: CRequest): Context;
+	static appendParsedData<B = unknown, S = unknown, P = unknown, R = unknown>(ctx: Context<B, S, P, R>, req: CRequest, params: Record<string, string>, search: Record<string, string>, model?: RouterModelData<B, S, P>): Promise<void>;
 }
-export type Func<Args extends any[] = any[], Return = any> = (...args: Args) => Return;
 export type MaybePromise<T> = Promise<T> | T;
 export type RouteHandler<B = unknown, S = unknown, P = unknown, R = unknown> = Func<[
 	Context<B, S, P, R>
@@ -526,17 +578,34 @@ declare abstract class RouteAbstract<Path extends string = string, B = unknown,
 	abstract id: RouteId;
 	abstract handler: RouteHandler<B, S, P, R>;
 	abstract model?: RouteModel<B, S, P, R>;
-	resolveEndpoint(definition: RouteDefinition<Path>, variant: RouteVariant): Path;
-	resolveMethod(definition: RouteDefinition<Path>): Method;
-	resolvePattern(endpoint: Path): RegExp;
-	resolveId(method: string, endpoint: Path): RouteId;
+	protected resolveEndpoint(definition: RouteDefinition<Path>, variant: RouteVariant): Path;
+	protected resolveMethod(definition: RouteDefinition<Path>): Method;
+	protected resolvePattern(endpoint: Path): RegExp;
+	protected resolveId(method: string, endpoint: Path): RouteId;
 }
 /**
- * The object to define an endpoint. Can be instantiated with "new" or inside a controller
- * with {@link ControllerAbstract.route}. The callback recieves the {@link Context} and can
- * return {@link HttpResponse} or any data. Route instantiation automatically registers
- * to the router.
- * */
+ * Defines an HTTP endpoint. Accepts a {@link RouteDefinition} which can either be a plain
+ * path string (defaults to GET) or an object with a `method` and `path` for other HTTP methods.
+ *
+ * The handler receives a {@link Context} and can return any data, a {@link CResponse} directly,
+ * or a plain web `Response` for cases where full control over the response is needed.
+ * Returned data is automatically serialized by {@link CResponse} — plain objects become JSON,
+ * primitives become plain text, and so on.
+ *
+ * An optional {@link RouteModel} can be provided to validate and parse the request body,
+ * URL params, and search params — the parsed results are typed and available on the context.
+ *
+ * Route instantiation automatically registers to the router.
+ *
+ * @example
+ * // GET /users
+ * new Route("/users", () => [{ id: 1 }]);
+ *
+ * // POST /users with typed body
+ * new Route({ method: C.Method.POST, path: "/users" }, (c) => {
+ *     return { created: c.body.name };
+ * }, { body: UserModel });
+ */
 export declare class Route<Path extends string = string, B = unknown, S = unknown, P = unknown, R = unknown> extends RouteAbstract<Path, B, S, P, R> {
 	constructor(definition: RouteDefinition<Path>, handler: RouteHandler<B, S, P, R>, model?: RouteModel<B, S, P, R>);
 	variant: RouteVariant;
@@ -547,52 +616,97 @@ export declare class Route<Path extends string = string, B = unknown, S = unknow
 	handler: RouteHandler<B, S, P, R>;
 	model?: RouteModel<B, S, P, R> | undefined;
 	static makeRouteId(method: string, endpoint: string): RouteId;
+	static makeRoutePattern(endpoint: string): RegExp;
 }
 export type AnyRoute = Route<string, any, any, any, any>;
-export type AnyRouteModel = RouteModel<any, any, any, any>;
 export type MiddlewareHandler = Func<[
 	Context
 ], MaybePromise<void>>;
 export type StaticRouteHandler<B = unknown, S = unknown, P = unknown> = Func<[
-	Context<B, S, P, string>,
-	string
-], MaybePromise<string>>;
+	context: Context<B, S, P, string | CResponse>,
+	content: string
+], MaybePromise<string | CResponse>>;
+export type StaticRouteDefinition = string | {
+	filePath: string;
+	stream: true;
+	disposition?: "attachment" | "inline";
+};
 /**
- * The object to define a route that serves a static file. Can be instantiated with "new" or inside a controller
- * with {@link ControllerAbstract.staticRoute}. The callback recieves the {@link Context} and can
- * return {@link HttpResponse} or any data. Route instantiation automatically registers
- * to the router.
- * */
-export declare class StaticRoute<Path extends string = string, B = unknown, S = unknown, P = unknown> extends RouteAbstract<Path, B, S, P, string> {
-	private filePath;
-	constructor(path: Path, filePath: string, handler?: StaticRouteHandler<B, S, P>, model?: RouteModel<B, S, P, string>);
+ * Defines a route that serves a static file. Accepts a path and a {@link StaticRouteDefinition}
+ * which can either be a plain file path string for a standard file response, or an object
+ * with `stream: true` to stream the file directly from disk — useful for large files like
+ * videos, PDFs, or large assets where reading the entire file into memory is undesirable.
+ *
+ * An optional custom handler can be provided to intercept the file content before it is sent,
+ * for example to modify headers or transform the content. Route instantiation automatically
+ * registers to the router.
+ *
+ * @example
+ * // Serve a file normally
+ * new StaticRoute("/style", "assets/style.css");
+ *
+ * // Stream a large file
+ * new StaticRoute("/video", { filePath: "assets/video.mp4", stream: true });
+ *
+ * // Custom handler
+ * new StaticRoute("/doc", "assets/doc.txt", (c, content) => {
+ *     c.res.headers.set("x-custom", "value");
+ *     return content;
+ * });
+ */
+export declare class StaticRoute<Path extends string = string, B = unknown, S = unknown, P = unknown> extends RouteAbstract<Path, B, S, P, string | CResponse> {
+	constructor(path: Path, definition: StaticRouteDefinition, handler?: StaticRouteHandler<B, S, P>, model?: RouteModel<B, S, P, string | CResponse>);
 	id: RouteId;
 	variant: RouteVariant;
 	method: Method;
 	endpoint: Path;
 	pattern: RegExp;
-	model?: RouteModel<B, S, P, string> | undefined;
-	handler: RouteHandler<B, S, P, string>;
-	private defaultHandler;
-	private get extension();
-	private getContent;
-	private mimeTypes;
-	private handleHtml;
-	private handleCss;
-	private handleJs;
-	private handleFile;
+	model?: RouteModel<B, S, P, string | CResponse> | undefined;
+	handler: RouteHandler<B, S, P, string | CResponse>;
+	private filePath;
+	private resolveFilePath;
+	private resolveHandler;
 }
 export type ControllerOptions = {
 	prefix?: string;
 	beforeEach?: (context: Context) => MaybePromise<void>;
 };
-/** Extend this class to create your own controllers. */
+/**
+ * Base class for grouping related routes under a shared prefix and optional middleware.
+ * Extend this class to create your own controllers.
+ *
+ * All routes registered via {@link ControllerAbstract.route} and {@link ControllerAbstract.staticRoute}
+ * automatically inherit the controller's prefix and run `beforeEach` before the handler if set.
+ *
+ * @example
+ * class UserController extends ControllerAbstract {
+ *     constructor() {
+ *         super({ prefix: "/users" });
+ *     }
+ *
+ *     getAll = this.route("/", () => getAllUsers());
+ *
+ *     create = this.route({ method: C.Method.POST, path: "/" }, (c) => createUser(c.body));
+ *
+ *     avatar = this.staticRoute("/avatar", { filePath: "assets/avatar.png", stream: true });
+ * }
+ *
+ * new UserController();
+ */
 declare abstract class ControllerAbstract {
 	constructor(opts?: ControllerOptions);
 	routeIds: Set<RouteId>;
 	protected prefix?: string;
 	protected beforeEach?: MiddlewareHandler;
+	/**
+	 * Registers a dynamic route under this controller. Behaves identically to {@link Route}
+	 * but automatically prepends the controller prefix and runs `beforeEach` before the handler.
+	 */
 	protected route<Path extends string = string, B = unknown, S = unknown, P = unknown, R = unknown>(...args: ConstructorParameters<typeof Route<Path, B, S, P, R>>): Route<Path, B, S, P, R>;
+	/**
+	 * Registers a static file route under this controller. Behaves identically to {@link StaticRoute}
+	 * but automatically prepends the controller prefix.
+	 */
 	protected staticRoute<Path extends string = string, B = unknown, S = unknown, P = unknown>(...args: ConstructorParameters<typeof StaticRoute<Path, B, S, P>>): StaticRoute<Path, B, S, P>;
 	private resolveRouteDefinition;
 }
@@ -610,37 +724,61 @@ export declare class Middleware {
 	useOn: MiddlewareUseOn;
 	handler: MiddlewareHandler;
 }
-export type RouterMiddlewareData = MiddlewareHandler;
+export type AnyRouteModel = RouteModel<any, any, any, any>;
 export type RouterRouteData = Pick<AnyRoute, "id" | "endpoint" | "method" | "pattern" | "handler">;
+export type RouterReturnData = {
+	route: RouterRouteData;
+	model: RouterModelData | undefined;
+	middleware: MiddlewareHandler | undefined;
+	params: Record<string, string>;
+	search: Record<string, string>;
+};
+export interface RouterAdapterInterface {
+	find(req: CRequest): RouterReturnData | null;
+	list(): Array<RouterRouteData>;
+	addRoute(data: RouterRouteData): void;
+	addModel(route: AnyRoute, model: AnyRouteModel): void;
+	addMiddleware(middleware: Middleware): void;
+}
 declare class Router {
-	private _routes;
-	private _middlewares;
-	private _models;
-	private internFuncMap;
+	constructor(adapter?: RouterAdapterInterface);
+	models: AnyRouteModel[];
+	private _adapter;
 	private cache;
-	get routes(): Map<string, RouterRouteData>;
-	get models(): Map<RouteId, RouterModelData>;
-	get middlewares(): Map<string, RouterMiddlewareData>;
-	globalPrefix: string;
-	setGlobalPrefix(value: string): void;
-	getRouteHandler(req: HttpRequest): Func<[
-	], Promise<HttpResponse>>;
+	checkPossibleCollision(n: RouterRouteData): boolean;
+	addModel(route: AnyRoute, model: AnyRouteModel): void;
+	addMiddleware(middleware: Middleware): void;
+	addRoute(r: AnyRoute): void;
+	findRouteHandler(req: CRequest): Func<[
+	], Promise<CResponse>>;
 	getRouteList(): Array<[
 		string,
 		string
 	]>;
-	addRoute(r: AnyRoute): void;
-	addMiddleware(m: Middleware): void;
-	addModel(routeId: RouteId, model: AnyRouteModel): void;
-	findRouterMiddlewareData(routeId: RouteId): RouterMiddlewareData | undefined;
-	findModel(routeId: RouteId): RouterModelData | undefined;
-	findRoute(req: HttpRequest): RouterRouteData;
-	private checkPossibleCollision;
-	private hasLastPartParam;
-	private removeLastParam;
-	private hasAnyParam;
-	private compile;
-	private intern;
+}
+declare class GlobalRouterStore extends StoreAbstract<Router | null> {
+	value: Router | null;
+	get(): Router;
+}
+export type CorsOptions = {
+	allowedOrigins?: string[];
+	allowedMethods?: string[];
+	allowedHeaders?: HeaderKey[];
+	credentials?: boolean;
+};
+/** Simple cors helper object to set cors headers */
+export declare class Cors {
+	readonly opts: CorsOptions | undefined;
+	constructor(opts: CorsOptions | undefined);
+	private readonly originKey;
+	private readonly methodsKey;
+	private readonly headersKey;
+	private readonly credentialsKey;
+	getCorsHeaders(req: CRequest, res: CResponse): CHeaders;
+	apply(req: CRequest, res: CResponse): void;
+}
+declare class GlobalCorsStore extends StoreAbstract<Cors | null> {
+	protected value: Cors | null;
 }
 export type ConfigEnvKey = OrString<keyof Env>;
 export type ConfigValueParser<T> = Func<[
@@ -658,117 +796,48 @@ export declare class Config {
 	}): T;
 	static set(key: string, value: string | number | boolean): void;
 }
-export type FileWalkerFile = {
-	text(): Promise<string>;
-};
-declare class FileWalkerUsingBun {
-	static read(address: string): Promise<string | null>;
-	static exists(address: string): Promise<boolean>;
-	static getExtension(address: string): string;
-	static find(address: string): Promise<FileWalkerFile | null>;
-}
-export declare class FileWalker extends FileWalkerUsingBun {
-}
-declare class HttpError extends Error {
+declare class CError extends Error {
 	message: string;
 	status: Status;
 	data?: unknown | undefined;
 	constructor(message: string, status: Status, data?: unknown | undefined);
-	toResponse(): HttpResponse;
+	toResponse(): CResponse;
 	isStatusOf(status: Status): boolean;
-	static internalServerError(msg?: string): HttpError;
-	static badRequest(msg?: string): HttpError;
-	static notFound(msg?: string): HttpError;
-	static methodNotAllowed(msg?: string): HttpError;
-	static unprocessableEntity(msg?: string): HttpError;
+	static internalServerError(msg?: string): CError;
+	static badRequest(msg?: string): CError;
+	static notFound(msg?: string): CError;
+	static methodNotAllowed(msg?: string): CError;
+	static unprocessableEntity(msg?: string): CError;
 }
 export type InferSchema<T extends Schema> = StandardSchemaV1.InferOutput<T>;
-export type Prettify<T> = {
-	[K in keyof T]: T[K];
-} & {};
-/** If you prefer to put all schemas into a single object, this will be helpful */
-export type InferModel<T extends Record<string, any>> = {
-	[K in keyof T]: T[K] extends RouteModel<any, any, any, any> ? Prettify<(T[K]["body"] extends Schema ? {
-		body: InferSchema<T[K]["body"]>;
-	} : {}) & (T[K]["search"] extends Schema ? {
-		search: InferSchema<T[K]["search"]>;
-	} : {}) & (T[K]["params"] extends Schema ? {
-		params: InferSchema<T[K]["params"]>;
-	} : {}) & (T[K]["response"] extends Schema ? {
-		response: InferSchema<T[K]["response"]>;
-	} : {})> : T[K] extends Schema ? InferSchema<T[K]> : never;
+export type ServerTlsOptions = {
+	cert: string | Buffer;
+	key: string | Buffer;
+	ca?: string | Buffer;
 };
-export type UnknownObject = Record<string, unknown>;
-export declare class Parser {
-	static parse<T = UnknownObject>(data: unknown, validate?: SchemaValidator<T>): Promise<T>;
-	static issuesToErrorMessage(issues: readonly StandardSchemaV1.Issue[]): string;
-	static getSearch<S = UnknownObject>(url: URL, validate?: SchemaValidator<S>): Promise<S>;
-	static getBody<B = UnknownObject>(r: HttpRequest | HttpResponse | Response, validate?: SchemaValidator<B>): Promise<B>;
-	static getParams<P = UnknownObject>(endpoint: string, url: URL, validate?: SchemaValidator<P>): Promise<P>;
-	private static getUnknownBody;
-	private static getJsonBody;
-	private static getFormUrlEncodedBody;
-	private static getFormDataBody;
-	private static getTextBody;
-	static getNormalizedContentType(input: Request | Response): string;
-	static processString(value: string): string | boolean | number;
-}
-/** Abstract class for repository implementations */
-declare abstract class RepositoryAbstract {
-	readonly db: DatabaseClientInterface;
-	constructor(db: DatabaseClientInterface);
-}
-export declare const DefaultStatusTexts: {
-	200: string;
-	201: string;
-	204: string;
-	301: string;
-	302: string;
-	303: string;
-	307: string;
-	308: string;
-	400: string;
-	401: string;
-	403: string;
-	404: string;
-	500: string;
+export type ServerOptions = {
+	adapter?: RouterAdapterInterface;
+	idleTimeout?: number;
+	tls?: ServerTlsOptions;
 };
-export type DefaultStatusTexts = ValueOf<typeof DefaultStatusTexts>;
-export type ServeOptions = {
+export type ServeArgs = {
 	port: number;
 	hostname?: "0.0.0.0" | "127.0.0.1" | "localhost" | (string & {}) | undefined;
 	fetch: (request: Request) => Promise<Response>;
 };
-export type CorsOptions = {
-	allowedOrigins?: string[];
-	allowedMethods?: string[];
-	allowedHeaders?: HttpHeaderKey[];
-	credentials?: boolean;
-};
-declare class Cors {
-	readonly opts: CorsOptions;
-	constructor(opts: CorsOptions);
-	private readonly originKey;
-	private readonly methodsKey;
-	private readonly headersKey;
-	private readonly credentialsKey;
-	getCorsHeaders(req: HttpRequest, res: HttpResponse): HttpHeaders;
-	apply(req: HttpRequest, res: HttpResponse): void;
-}
 export type ErrorHandler<R = unknown> = Func<[
 	Error
-], MaybePromise<HttpResponse<R>>>;
+], MaybePromise<CResponse<R>>>;
 export type RequestHandler<R = unknown> = Func<[
-	HttpRequest
-], MaybePromise<HttpResponse<R>>>;
+	CRequest
+], MaybePromise<CResponse<R>>>;
 export type AfterResponseHandler = Func<[
-	HttpResponse
-], MaybePromise<HttpResponse>> | undefined;
+	CResponse
+], MaybePromise<CResponse>>;
 export interface ServerInterface {
-	serve(options: ServeOptions): void;
+	serve(options: ServeArgs): void;
 	close(): Promise<void>;
 	setGlobalPrefix(value: string): void;
-	setCors(cors: CorsOptions): void;
 	/**
 	 *
 	 * Default error handler response will have a status of C.Error or 500 and json:
@@ -797,38 +866,48 @@ export interface ServerInterface {
 	setOnBeforeListen(handler: () => MaybePromise<void>): void;
 	setOnBeforeClose(handler: () => MaybePromise<void>): void;
 	setOnAfterResponse(handler: AfterResponseHandler): void;
-	listen(port: ServeOptions["port"], hostname: ServeOptions["hostname"]): Promise<void>;
+	listen(port: ServeArgs["port"], hostname: ServeArgs["hostname"]): Promise<void>;
 	handle(request: Request): Promise<Response>;
 }
 declare abstract class ServerAbstract implements ServerInterface {
-	abstract serve(options: ServeOptions): void;
+	protected readonly opts?: ServerOptions | undefined;
+	abstract serve(options: ServeArgs): void;
 	abstract close(): Promise<void>;
-	protected cors: Cors | undefined;
+	constructor(opts?: ServerOptions | undefined);
 	get routes(): Array<[
 		string,
 		string
 	]>;
 	setGlobalPrefix(value: string): void;
-	setCors(cors: CorsOptions): void;
-	setOnError(handler: ErrorHandler): void;
-	setOnNotFound(handler: RequestHandler): void;
-	setOnBeforeListen(handler: () => MaybePromise<void>): void;
-	setOnBeforeClose(handler: () => MaybePromise<void>): void;
-	setOnAfterResponse(handler: AfterResponseHandler): void;
-	listen(port: ServeOptions["port"], hostname?: ServeOptions["hostname"]): Promise<void>;
+	listen(port: ServeArgs["port"], hostname?: ServeArgs["hostname"]): Promise<void>;
 	handle(request: Request): Promise<Response>;
 	private getResponse;
-	protected handleBeforeListen: (() => MaybePromise<void>) | undefined;
-	protected handleBeforeClose: (() => MaybePromise<void>) | undefined;
-	protected handleAfterResponse: AfterResponseHandler;
+	protected handleBeforeListen: Func<[
+	], MaybePromise<void>> | undefined;
+	setOnBeforeListen(handler: Func<[
+	], MaybePromise<void>> | undefined): void;
+	defaultOnBeforeListen: Func<[
+	], MaybePromise<void>> | undefined;
+	protected handleBeforeClose: Func<[
+	], MaybePromise<void>> | undefined;
+	setOnBeforeClose(handler: () => MaybePromise<void>): void;
+	defaultOnBeforeClose: Func<[
+	], MaybePromise<void>> | undefined;
+	protected handleAfterResponse: AfterResponseHandler | undefined;
+	setOnAfterResponse(handler: AfterResponseHandler | undefined): void;
+	defaultOnAfterResponse: AfterResponseHandler | undefined;
 	protected handleError: ErrorHandler;
+	setOnError(handler: ErrorHandler): void;
+	defaultErrorHandler: ErrorHandler;
 	protected handleNotFound: RequestHandler;
+	setOnNotFound(handler: RequestHandler): void;
+	defaultNotFoundHandler: RequestHandler;
 	protected handleMethodNotAllowed: RequestHandler;
+	defaultMethodNotFoundHandler: RequestHandler;
 }
 declare class ServerUsingBun extends ServerAbstract {
 	private app;
-	constructor();
-	serve(options: ServeOptions): void;
+	serve(args: ServeArgs): void;
 	close(): Promise<void>;
 	private createApp;
 }
@@ -838,28 +917,112 @@ declare class ServerUsingBun extends ServerAbstract {
  */
 export declare class Server extends ServerUsingBun {
 }
-export declare function getRouterInstance(): Router;
-export declare function setRouterInstance(router: Router): void;
+export interface XFileInterface {
+	get name(): string;
+	get extension(): string;
+	get mimeType(): string;
+	exists(): Promise<boolean>;
+	text(): Promise<string>;
+	stream(): ReadableStream;
+}
+declare abstract class XFileAbstract implements XFileInterface {
+	readonly path: string;
+	private readonly fallbackExtension?;
+	constructor(path: string, fallbackExtension?: string | undefined);
+	abstract text(): Promise<string>;
+	abstract stream(): ReadableStream;
+	abstract exists(): Promise<boolean>;
+	get name(): string;
+	get extension(): string;
+	get mimeType(): string;
+}
+declare class XFileUsingBun extends XFileAbstract implements XFileInterface {
+	constructor(...args: ConstructorParameters<typeof XFileAbstract>);
+	file: Bun.BunFile;
+	exists(): Promise<boolean>;
+	text(): Promise<string>;
+	stream(): ReadableStream;
+}
+declare class XFile extends XFileUsingBun {
+}
+/** Abstract class for repository implementations */
+declare abstract class RepositoryAbstract {
+	readonly db: DatabaseClientInterface;
+	constructor(db: DatabaseClientInterface);
+}
+/** Router Adapter for the "memoirist" package. */
+export declare class MemoiristAdapter implements RouterAdapterInterface {
+	private router;
+	private pendingMiddlewares;
+	find(req: CRequest): RouterReturnData | null;
+	list(): Array<RouterRouteData>;
+	addRoute(data: RouterRouteData): void;
+	addModel(route: AnyRoute, model: AnyRouteModel): void;
+	addMiddleware(middleware: Middleware): void;
+}
+export type UnknownObject = Record<string, unknown>;
+export declare class Parser {
+	static parse<T = UnknownObject>(data: unknown, validate?: SchemaValidator<T>): Promise<T>;
+	static issuesToErrorMessage(issues: readonly StandardSchemaV1.Issue[]): string;
+	static parseUrlData<P = UnknownObject>(params: Record<string, string>, validate?: SchemaValidator<P>): Promise<P>;
+	/** This can be used for both request and response bodies */
+	static parseBody<B = UnknownObject>(r: CRequest | CResponse | Response, validate?: SchemaValidator<B>): Promise<B>;
+	private static getUnknownBody;
+	private static getJsonBody;
+	private static getFormUrlEncodedBody;
+	private static getFormDataBody;
+	private static getTextBody;
+	static getNormalizedContentType(input: Request | Response): string;
+}
+export type Prettify<T> = {
+	[K in keyof T]: T[K];
+} & {};
+/** If you prefer to put all schemas into a single object, this will be helpful */
+export type InferModel<T extends Record<string, any>> = {
+	[K in keyof T]: T[K] extends RouteModel<any, any, any, any> ? Prettify<(T[K]["body"] extends Schema ? {
+		body: InferSchema<T[K]["body"]>;
+	} : {}) & (T[K]["search"] extends Schema ? {
+		search: InferSchema<T[K]["search"]>;
+	} : {}) & (T[K]["params"] extends Schema ? {
+		params: InferSchema<T[K]["params"]>;
+	} : {}) & (T[K]["response"] extends Schema ? {
+		response: InferSchema<T[K]["response"]>;
+	} : {})> : T[K] extends Schema ? InferSchema<T[K]> : never;
+};
+export declare const _prefixStore: GlobalPrefixStore;
+export declare const _routerStore: GlobalRouterStore;
+export declare const _corsStore: GlobalCorsStore;
 
+declare namespace X {
+	export { Cors, CorsOptions, InferModel, MemoiristAdapter, Parser, RepositoryAbstract as Repository, XFile as File };
+}
 declare namespace C {
-	export { CommonHeaders, Config, Context, ContextDataInterface, ControllerAbstract as Controller, ControllerOptions, CookieOptions, Cookies, CookiesInit, DatabaseClientInterface, DefaultStatusTexts, Env, FileWalker, FileWalkerFile, HttpError as Error, HttpHeaderKey as HeaderKey, HttpHeaders as Headers, HttpHeadersInit as HeadersInit, HttpRequest as Request, HttpRequestInfo as RequestInfo, HttpRequestInit as RequestInit, HttpResponse as Response, HttpResponseBody as ResponseBody, HttpResponseInit as ResponseInit, InferModel, InferSchema, Method, Middleware, MiddlewareHandler, MiddlewareOptions, MiddlewareUseOn, Parser, RepositoryAbstract as Repository, Route, RouteDefinition, RouteHandler, RouteModel, Schema, SchemaValidator, ServeOptions, Server, StaticRoute, StaticRouteHandler, Status };
+	export { CError as Error, CHeaders as Headers, CHeadersInit as HeadersInit, CRequest as Request, CRequestInfo as RequestInfo, CRequestInit as RequestInit, CResponse as Response, CResponseBody as ResponseBody, CResponseInit as ResponseInit, CommonHeaders, Config, Context, ControllerAbstract as Controller, ControllerOptions, CookieOptions, Cookies, CookiesInit, HeaderKey, InferSchema, Method, Middleware, MiddlewareHandler, MiddlewareOptions, MiddlewareUseOn, Route, RouteDefinition, RouteHandler, Schema, SchemaValidator, ServeArgs, Server, ServerOptions, ServerTlsOptions, StaticRoute, StaticRouteHandler, Status };
+}
+declare namespace _default {
+	export { CError as Error, CHeaders as Headers, CHeadersInit as HeadersInit, CRequest as Request, CRequestInfo as RequestInfo, CRequestInit as RequestInit, CResponse as Response, CResponseBody as ResponseBody, CResponseInit as ResponseInit, CommonHeaders, Config, Context, ControllerAbstract as Controller, ControllerOptions, CookieOptions, Cookies, CookiesInit, HeaderKey, InferSchema, Method, Middleware, MiddlewareHandler, MiddlewareOptions, MiddlewareUseOn, Route, RouteDefinition, RouteHandler, Schema, SchemaValidator, ServeArgs, Server, ServerOptions, ServerTlsOptions, StaticRoute, StaticRouteHandler, Status };
+}
+declare namespace Extra {
+	export { Cors, CorsOptions, InferModel, MemoiristAdapter, Parser, RepositoryAbstract as Repository, XFile as File };
 }
 
 export {
 	C,
 	C as default,
+	CError as Error,
+	CHeaders as Headers,
+	CHeadersInit as HeadersInit,
+	CRequest as Request,
+	CRequestInfo as RequestInfo,
+	CRequestInit as RequestInit,
+	CResponse as Response,
+	CResponseBody as ResponseBody,
+	CResponseInit as ResponseInit,
 	ControllerAbstract as Controller,
-	HttpError as Error,
-	HttpHeaderKey as HeaderKey,
-	HttpHeaders as Headers,
-	HttpHeadersInit as HeadersInit,
-	HttpRequest as Request,
-	HttpRequestInfo as RequestInfo,
-	HttpRequestInit as RequestInit,
-	HttpResponse as Response,
-	HttpResponseBody as ResponseBody,
-	HttpResponseInit as ResponseInit,
+	Extra,
 	RepositoryAbstract as Repository,
+	X,
+	XFile as File,
 };
 
 export {};