@ozanarslan/corpus 0.2.0

package/dist/index.d.ts

@@ -0,0 +1,758 @@
+// Generated by dts-bundle-generator v9.5.1
+
+/// <reference types="node" />
+
+export type ValueOf<T> = T[keyof T];
+/** Just some common headers. */
+export declare const CommonHeaders: {
+	/** Controls caching mechanisms for requests and responses */
+	readonly CacheControl: "Cache-Control";
+	/** Specifies the media type of the resource or data */
+	readonly ContentType: "Content-Type";
+	/** Indicates the size of the entity-body in bytes */
+	readonly ContentLength: "Content-Length";
+	/** Specifies the character encodings that are acceptable */
+	readonly AcceptEncoding: "Accept-Encoding";
+	/** Informs the server about the types of data that can be sent back */
+	readonly Accept: "Accept";
+	/** Contains the credentials to authenticate with the server */
+	readonly Authorization: "Authorization";
+	/** The user agent string of the client software */
+	readonly UserAgent: "User-Agent";
+	/** The domain name of the server and port number */
+	readonly Host: "Host";
+	/** The address of the previous web page from which the current request originated */
+	readonly Referer: "Referer";
+	/** Indicates whether the connection should be kept alive */
+	readonly Connection: "Connection";
+	/** Used to specify directives that must be obeyed by caching mechanisms */
+	readonly Pragma: "Pragma";
+	/** The date and time at which the message was sent */
+	readonly Date: "Date";
+	/** Makes the request conditional based on the ETag of the resource */
+	readonly IfNoneMatch: "If-None-Match";
+	/** Makes the request conditional based on the last modification date */
+	readonly IfModifiedSince: "If-Modified-Since";
+	/** An identifier for a specific version of a resource */
+	readonly ETag: "ETag";
+	/** The date and time after which the response is considered stale */
+	readonly Expires: "Expires";
+	/** The last modification date of the resource */
+	readonly LastModified: "Last-Modified";
+	/** Indicates the URL to redirect a page to */
+	readonly Location: "Location";
+	/** Defines the authentication method that should be used */
+	readonly WWWAuthenticate: "WWW-Authenticate";
+	/** Allows the server to indicate its origin */
+	readonly AccessControlAllowOrigin: "Access-Control-Allow-Origin";
+	/** Determines how long the results of a preflight request can be cached */
+	readonly AccessControlMaxAge: "Access-Control-Max-Age";
+	/** Indicates whether the response can be shared with resources with credentials */
+	readonly AccessControlAllowCredentials: "Access-Control-Allow-Credentials";
+	readonly AccessControlRequestMethod: "Access-Control-Request-Method";
+	readonly SetCookie: "Set-Cookie";
+	readonly Cookie: "Cookie";
+};
+export type CommonHeaders = ValueOf<typeof CommonHeaders>;
+/** Commonly used HTTP verbs. */
+export declare const Method: {
+	readonly GET: "GET";
+	readonly POST: "POST";
+	readonly PUT: "PUT";
+	readonly PATCH: "PATCH";
+	readonly DELETE: "DELETE";
+	readonly HEAD: "HEAD";
+	readonly OPTIONS: "OPTIONS";
+	readonly CONNECT: "CONNECT";
+	readonly TRACE: "TRACE";
+};
+export type Method = ValueOf<typeof Method>;
+/** Commonly used HTTP status codes. */
+export declare const Status: {
+	/** --- 1xx Informational --- */
+	/** Continue: Request received, please continue */
+	readonly CONTINUE: 100;
+	/** Switching Protocols: Protocol change request approved */
+	readonly SWITCHING_PROTOCOLS: 101;
+	/** Processing (WebDAV) */
+	readonly PROCESSING: 102;
+	/** Early Hints */
+	readonly EARLY_HINTS: 103;
+	/** --- 2xx Success --- */
+	/** OK: Request succeeded */
+	readonly OK: 200;
+	/** Created: Resource created */
+	readonly CREATED: 201;
+	/** Accepted: Request accepted but not completed */
+	readonly ACCEPTED: 202;
+	/** Non-Authoritative Information */
+	readonly NON_AUTHORITATIVE_INFORMATION: 203;
+	/** No Content: Request succeeded, no body returned */
+	readonly NO_CONTENT: 204;
+	/** Reset Content: Clear form or view */
+	readonly RESET_CONTENT: 205;
+	/** Partial Content: Partial GET successful (e.g. range requests) */
+	readonly PARTIAL_CONTENT: 206;
+	/** Multi-Status (WebDAV) */
+	readonly MULTI_STATUS: 207;
+	/** Already Reported (WebDAV) */
+	readonly ALREADY_REPORTED: 208;
+	/** IM Used (HTTP Delta encoding) */
+	readonly IM_USED: 226;
+	/** --- 3xx Redirection --- */
+	/** Multiple Choices */
+	readonly MULTIPLE_CHOICES: 300;
+	/** Moved Permanently: Resource moved to a new URL */
+	readonly MOVED_PERMANENTLY: 301;
+	/** Found: Resource temporarily under different URI */
+	readonly FOUND: 302;
+	/** See Other: Redirect to another URI using GET */
+	readonly SEE_OTHER: 303;
+	/** Not Modified: Cached version is still valid */
+	readonly NOT_MODIFIED: 304;
+	/** Use Proxy: Deprecated */
+	readonly USE_PROXY: 305;
+	/** Temporary Redirect: Resource temporarily at another URI */
+	readonly TEMPORARY_REDIRECT: 307;
+	/** Permanent Redirect: Resource permanently at another URI */
+	readonly PERMANENT_REDIRECT: 308;
+	/** --- 4xx Client Errors --- */
+	/** Bad Request: Malformed request */
+	readonly BAD_REQUEST: 400;
+	/** Unauthorized: Missing or invalid auth credentials */
+	readonly UNAUTHORIZED: 401;
+	/** Payment Required: Reserved for future use */
+	readonly PAYMENT_REQUIRED: 402;
+	/** Forbidden: Authenticated but no permission */
+	readonly FORBIDDEN: 403;
+	/** Not Found: Resource does not exist */
+	readonly NOT_FOUND: 404;
+	/** Method Not Allowed: HTTP method not allowed */
+	readonly METHOD_NOT_ALLOWED: 405;
+	/** Not Acceptable: Response not acceptable by client */
+	readonly NOT_ACCEPTABLE: 406;
+	/** Proxy Authentication Required */
+	readonly PROXY_AUTHENTICATION_REQUIRED: 407;
+	/** Request Timeout: Server timeout waiting for client */
+	readonly REQUEST_TIMEOUT: 408;
+	/** Conflict: Request conflict (e.g. duplicate resource) */
+	readonly CONFLICT: 409;
+	/** Gone: Resource is no longer available */
+	readonly GONE: 410;
+	/** Length Required: Missing Content-Length header */
+	readonly LENGTH_REQUIRED: 411;
+	/** Precondition Failed */
+	readonly PRECONDITION_FAILED: 412;
+	/** Payload Too Large */
+	readonly PAYLOAD_TOO_LARGE: 413;
+	/** URI Too Long */
+	readonly URI_TOO_LONG: 414;
+	/** Unsupported Media Type */
+	readonly UNSUPPORTED_MEDIA_TYPE: 415;
+	/** Range Not Satisfiable */
+	readonly RANGE_NOT_SATISFIABLE: 416;
+	/** Expectation Failed */
+	readonly EXPECTATION_FAILED: 417;
+	/** I'm a teapot: Joke response for coffee machines */
+	readonly IM_A_TEAPOT: 418;
+	/** Misdirected Request: Sent to the wrong server */
+	readonly MISDIRECTED_REQUEST: 421;
+	/** Unprocessable Entity (WebDAV) */
+	readonly UNPROCESSABLE_ENTITY: 422;
+	/** Locked (WebDAV) */
+	readonly LOCKED: 423;
+	/** Failed Dependency (WebDAV) */
+	readonly FAILED_DEPENDENCY: 424;
+	/** Too Early: Request might be replayed */
+	readonly TOO_EARLY: 425;
+	/** Upgrade Required */
+	readonly UPGRADE_REQUIRED: 426;
+	/** Precondition Required */
+	readonly PRECONDITION_REQUIRED: 428;
+	/** Too Many Requests: Rate limiting */
+	readonly TOO_MANY_REQUESTS: 429;
+	/** Request Header Fields Too Large */
+	readonly REQUEST_HEADER_FIELDS_TOO_LARGE: 431;
+	/** Unavailable For Legal Reasons */
+	readonly UNAVAILABLE_FOR_LEGAL_REASONS: 451;
+	/** --- 5xx Server Errors --- */
+	/** Internal Server Error: Unhandled server error */
+	readonly INTERNAL_SERVER_ERROR: 500;
+	/** Not Implemented: Endpoint/method not implemented */
+	readonly NOT_IMPLEMENTED: 501;
+	/** Bad Gateway: Invalid response from upstream server */
+	readonly BAD_GATEWAY: 502;
+	/** Service Unavailable: Server temporarily overloaded/down */
+	readonly SERVICE_UNAVAILABLE: 503;
+	/** Gateway Timeout: No response from upstream server */
+	readonly GATEWAY_TIMEOUT: 504;
+	/** HTTP Version Not Supported */
+	readonly HTTP_VERSION_NOT_SUPPORTED: 505;
+	/** Variant Also Negotiates */
+	readonly VARIANT_ALSO_NEGOTIATES: 506;
+	/** Insufficient Storage (WebDAV) */
+	readonly INSUFFICIENT_STORAGE: 507;
+	/** Loop Detected (WebDAV) */
+	readonly LOOP_DETECTED: 508;
+	/** Not Extended */
+	readonly NOT_EXTENDED: 510;
+	/** Network Authentication Required */
+	readonly NETWORK_AUTHENTICATION_REQUIRED: 511;
+};
+export type Status = ValueOf<typeof Status> | number;
+export type ConfigValueParser<T> = (value: string) => T;
+export interface DatabaseClientInterface {
+}
+export interface ContextDataInterface {
+}
+export interface Env {
+}
+export type OrString<T> = T | (string & {});
+export type ConfigEnvKey = OrString<keyof Env>;
+export declare class Config {
+	static get env(): NodeJS.ProcessEnv;
+	static cwd(): string;
+	static resolvePath(...paths: string[]): string;
+	static get<T = string>(key: ConfigEnvKey, opts?: {
+		parser?: ConfigValueParser<T>;
+		fallback?: T;
+	}): T;
+	static set(key: string, value: string): void;
+}
+export type HttpHeaderKey = OrString<CommonHeaders>;
+export type CorsOptions = {
+	allowedOrigins?: string[];
+	allowedMethods?: string[];
+	allowedHeaders?: HttpHeaderKey[];
+	credentials?: boolean;
+};
+export type CookieOptions = {
+	name: string;
+	value: string;
+	domain?: string;
+	/** Defaults to '/'. */
+	path?: string;
+	expires?: number | Date;
+	secure?: boolean;
+	/** Defaults to `lax`. */
+	sameSite?: "strict" | "lax" | "none";
+	httpOnly?: boolean;
+	partitioned?: boolean;
+	maxAge?: number;
+};
+export interface CookiesInterface {
+	set(opts: CookieOptions): void;
+	get(name: string): string | null;
+	has(name: string): boolean;
+	delete(opts: Pick<CookieOptions, "name" | "domain" | "path">): void;
+	entries(): IterableIterator<[
+		string,
+		string
+	]>;
+	values(): Array<string>;
+	keys(): Array<string>;
+	decodeValue(cookieString: string): string | null;
+	createHeader(opts: CookieOptions): string;
+	toSetCookieHeaders(): string[];
+}
+export type HttpHeadersInit = Headers | HttpHeadersInterface | [
+	string,
+	string
+][] | (Record<string, string> & Partial<Record<HttpHeaderKey, string>>);
+interface HttpHeadersInterface extends Headers {
+	append(name: HttpHeaderKey, value: string): void;
+	set(name: HttpHeaderKey, value: string): void;
+	combine(source: HttpHeadersInterface, target: HttpHeadersInterface): HttpHeadersInterface;
+	innerCombine(source: HttpHeadersInterface): HttpHeadersInterface;
+	setMany(init: HttpHeadersInit): void;
+}
+export type HttpResponseBody<R = unknown> = R | BodyInit | null | undefined;
+export type CookiesInit = CookiesInterface | [
+	string,
+	string
+][] | Record<string, string>;
+export type HttpResponseInit = {
+	cookies?: CookiesInit;
+	headers?: HttpHeadersInit;
+	status?: Status;
+	statusText?: string;
+};
+interface HttpResponseInterface<R = unknown> {
+	readonly body?: HttpResponseBody<R>;
+	readonly init?: HttpResponseInit;
+	headers: HttpHeadersInterface;
+	status: Status;
+	statusText: string;
+	cookies: CookiesInterface;
+	get response(): Response;
+}
+export type MaybePromise<T> = Promise<T> | T;
+export type ErrorHandler<R = unknown> = (err: Error) => MaybePromise<HttpResponseInterface<R>>;
+export type HttpRequestInfo = Request | string | HttpRequestInterface;
+export type HttpRequestInit = Omit<RequestInit, "headers" | "method"> & {
+	headers?: HttpHeadersInit;
+	method?: Method;
+};
+interface HttpRequestInterface extends Request {
+	readonly input: HttpRequestInfo;
+	readonly init?: HttpRequestInit;
+	readonly cookies: CookiesInterface;
+	get headers(): HttpHeadersInterface;
+	get isPreflight(): boolean;
+	get urlObject(): URL;
+}
+export type RequestHandler<R = unknown> = (req: HttpRequestInterface) => MaybePromise<HttpResponseInterface<R>>;
+export type ServeOptions = {
+	port: number;
+	hostname?: "0.0.0.0" | "127.0.0.1" | "localhost" | (string & {}) | undefined;
+	fetch: (request: Request) => Promise<Response>;
+};
+export interface ServerInterface {
+	serve(options: ServeOptions): void;
+	listen(port: ServeOptions["port"], hostname: ServeOptions["hostname"]): Promise<void>;
+	exit(): Promise<void>;
+	handle(request: Request): Promise<Response>;
+	setGlobalPrefix(value: string): void;
+	setCors(cors: CorsOptions): void;
+	setOnError(handler: ErrorHandler): void;
+	setOnNotFound(handler: RequestHandler): void;
+	setOnBeforeListen(handler: () => MaybePromise<void>): void;
+	setOnBeforeExit(handler: () => MaybePromise<void>): void;
+	setOnAfterResponse(handler: (res: HttpResponseInterface) => MaybePromise<HttpResponseInterface>): void;
+}
+export interface CorsInterface {
+	readonly opts: CorsOptions;
+	getCorsHeaders(req: HttpRequestInterface, res: HttpResponseInterface): HttpHeadersInterface;
+	apply(req: HttpRequestInterface, res: HttpResponseInterface): void;
+}
+declare abstract class ServerAbstract implements ServerInterface {
+	constructor();
+	abstract serve(options: ServeOptions): void;
+	abstract exit(): Promise<void>;
+	protected cors: CorsInterface | undefined;
+	protected handleBeforeListen: (() => MaybePromise<void>) | undefined;
+	protected handleBeforeExit: (() => MaybePromise<void>) | undefined;
+	protected handleAfterResponse: ((res: HttpResponseInterface) => MaybePromise<HttpResponseInterface>) | undefined;
+	setGlobalPrefix(value: string): void;
+	setCors(cors: CorsOptions): void;
+	setOnError(handler: ErrorHandler): void;
+	setOnNotFound(handler: RequestHandler): void;
+	setOnBeforeListen(handler: () => MaybePromise<void>): void;
+	setOnBeforeExit(handler: () => MaybePromise<void>): void;
+	setOnAfterResponse(handler: (res: HttpResponseInterface) => MaybePromise<HttpResponseInterface>): void;
+	listen(port: ServeOptions["port"], hostname?: ServeOptions["hostname"]): Promise<void>;
+	handle(request: Request): Promise<Response>;
+	private prepare;
+	private handleError;
+	private handleNotFound;
+	private handleMethodNotAllowed;
+	private handlePreflight;
+	private handleRoute;
+	private getResponse;
+}
+/**
+ * Server is the entrypoint to the app. It must be initialized before registering routes and middlewares.
+ * ".listen()" to start listening.
+ */
+export declare class Server extends ServerAbstract implements ServerInterface {
+	constructor();
+	serve(options: ServeOptions): void;
+	exit(): Promise<void>;
+	private instance;
+	private getInstance;
+}
+declare abstract class CookiesAbstract implements CookiesInterface {
+	abstract set(opts: CookieOptions): void;
+	abstract get(name: string): string | null;
+	abstract has(name: string): boolean;
+	abstract delete(opts: Pick<CookieOptions, "name" | "domain" | "path">): void;
+	abstract entries(): IterableIterator<[
+		string,
+		string
+	]>;
+	abstract values(): Array<string>;
+	abstract keys(): Array<string>;
+	abstract toSetCookieHeaders(): Array<string>;
+	applyInit(init: CookiesInit): void;
+	decodeValue(cookieString: string): string | null;
+	createHeader(opts: CookieOptions): string;
+}
+/** Simple cookie map/jar to collect and manipulate cookies. */
+export declare class Cookies extends CookiesAbstract implements CookiesInterface {
+	constructor(init?: CookiesInit);
+	private instance;
+	private getInstance;
+	set(opts: CookieOptions): void;
+	get(name: string): string | null;
+	has(name: string): boolean;
+	delete(opts: Pick<CookieOptions, "name" | "path" | "domain">): void;
+	entries(): IterableIterator<[
+		string,
+		string
+	]>;
+	values(): Array<string>;
+	keys(): Array<string>;
+	toSetCookieHeaders(): Array<string>;
+}
+/** Headers is extended to include helpers and intellisense for common header names. */
+declare class HttpHeaders extends Headers implements HttpHeadersInterface {
+	constructor(init?: HttpHeadersInit);
+	append(name: HttpHeaderKey, value: string): void;
+	set(name: HttpHeaderKey, value: string): void;
+	get(name: string): string | null;
+	has(name: string): boolean;
+	combine(source: HttpHeadersInterface, target: HttpHeadersInterface): HttpHeadersInterface;
+	innerCombine(source: HttpHeadersInterface): HttpHeadersInterface;
+	setMany(init: HttpHeadersInit): void;
+	static findHeaderInInit(init: HttpHeadersInit, name: HttpHeaderKey): string | null;
+}
+interface HttpErrorInterface extends Error {
+	message: string;
+	status: Status;
+	data?: unknown;
+}
+declare class HttpError extends Error implements HttpErrorInterface {
+	message: string;
+	status: Status;
+	data?: unknown | undefined;
+	constructor(message: string, status: Status, data?: unknown | undefined);
+	static isStatusOf(err: unknown, 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;
+}
+/** HttpRequest includes a cookie jar, better headers, and some utilities. */
+declare class HttpRequest extends Request implements HttpRequestInterface {
+	readonly input: HttpRequestInfo;
+	readonly init?: HttpRequestInit | undefined;
+	constructor(input: HttpRequestInfo, init?: HttpRequestInit | undefined);
+	get urlObject(): URL;
+	get headers(): HttpHeadersInterface;
+	/** Gets cookie header and collects cookies for the jar */
+	get cookies(): CookiesInterface;
+	get isPreflight(): boolean;
+}
+/**
+ * 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> implements HttpResponseInterface<R> {
+	readonly body?: HttpResponseBody<R>;
+	readonly init?: HttpResponseInit | undefined;
+	constructor(body?: HttpResponseBody<R>, init?: HttpResponseInit | undefined);
+	headers: HttpHeadersInterface;
+	status: Status;
+	statusText: string;
+	cookies: CookiesInterface;
+	get response(): Response;
+	private getCookies;
+	private getHeaders;
+	private getStatus;
+	private setContentType;
+	private getBody;
+	private getDefaultStatusText;
+	static redirect(url: string | URL, init?: HttpResponseInit): HttpResponseInterface;
+	static permanentRedirect(url: string | URL, init?: Omit<HttpResponseInit, "status">): HttpResponseInterface;
+	static temporaryRedirect(url: string | URL, init?: Omit<HttpResponseInit, "status">): HttpResponseInterface;
+	static seeOther(url: string | URL, init?: Omit<HttpResponseInit, "status">): HttpResponseInterface;
+}
+export interface ContextInterface<R = unknown, B = unknown, S = unknown, P = unknown> {
+	readonly req: HttpRequestInterface;
+	readonly url: URL;
+	readonly headers: HttpHeadersInterface;
+	readonly cookies: CookiesInterface;
+	body: B;
+	search: S;
+	params: P;
+	res: HttpResponseInterface<R>;
+	data: ContextDataInterface;
+}
+export type RouteHandler<R = unknown, B = unknown, S = unknown, P = unknown> = (context: ContextInterface<R, B, S, P>) => MaybePromise<R>;
+export type RouteId = `[${string}:${string}]`;
+declare const RouteVariant: {
+	readonly static: "static";
+	readonly dynamic: "dynamic";
+};
+export type RouteVariant = ValueOf<typeof RouteVariant>;
+export interface RouteInterface<Path extends string = string, R = unknown, B = unknown, S = unknown, P = unknown> {
+	id: RouteId;
+	variant: RouteVariant;
+	method: Method;
+	endpoint: Path;
+	pattern: RegExp;
+	handler: RouteHandler<R, B, S, P>;
+}
+export type RouteDefinition<Path extends string = string> = {
+	method: Method;
+	path: Path;
+} | Path;
+declare abstract class RouteAbstract<Path extends string = string, R = unknown, B = unknown, S = unknown, P = unknown> implements RouteInterface<Path, R, B, S, P> {
+	abstract variant: RouteVariant;
+	abstract endpoint: Path;
+	abstract method: Method;
+	abstract pattern: RegExp;
+	abstract id: RouteId;
+	abstract handler: RouteHandler<R, B, S, P>;
+	resolveEndpoint(definition: RouteDefinition<Path>, variant: RouteVariant): Path;
+	resolveMethod(definition: RouteDefinition<Path>): Method;
+	resolvePattern(endpoint: Path): RegExp;
+	resolveId(method: Method, endpoint: Path): RouteId;
+}
+/** From https://github.com/standard-schema/standard-schema */
+/** The Standard Typed interface. This is a base type extended by other specs. */
+export interface StandardTypedV1<Input = unknown, Output = Input> {
+	/** The Standard properties. */
+	readonly "~standard": StandardTypedV1.Props<Input, Output>;
+}
+declare namespace StandardTypedV1 {
+	/** The Standard Typed properties interface. */
+	interface Props<Input = unknown, Output = Input> {
+		/** The version number of the standard. */
+		readonly version: 1;
+		/** The vendor name of the schema library. */
+		readonly vendor: string;
+		/** Inferred types associated with the schema. */
+		readonly types?: Types<Input, Output> | undefined;
+	}
+	/** The Standard Typed types interface. */
+	interface Types<Input = unknown, Output = Input> {
+		/** The input type of the schema. */
+		readonly input: Input;
+		/** The output type of the schema. */
+		readonly output: Output;
+	}
+	/** Infers the input type of a Standard Typed. */
+	type InferInput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+	/** Infers the output type of a Standard Typed. */
+	type InferOutput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+}
+/** The Standard Schema interface. */
+export interface StandardSchemaV1<Input = unknown, Output = Input> {
+	/** The Standard Schema properties. */
+	readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1 {
+	/** The Standard Schema properties interface. */
+	interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+		/** Validates unknown input values. */
+		readonly validate: (value: unknown, options?: StandardSchemaV1.Options | undefined) => Result<Output> | Promise<Result<Output>>;
+	}
+	/** The result interface of the validate function. */
+	type Result<Output> = SuccessResult<Output> | FailureResult;
+	/** The result interface if validation succeeds. */
+	interface SuccessResult<Output> {
+		/** The typed output value. */
+		readonly value: Output;
+		/** A falsy value for `issues` indicates success. */
+		readonly issues?: undefined;
+	}
+	interface Options {
+		/** Explicit support for additional vendor-specific parameters, if needed. */
+		readonly libraryOptions?: Record<string, unknown> | undefined;
+	}
+	/** The result interface if validation fails. */
+	interface FailureResult {
+		/** The issues of failed validation. */
+		readonly issues: ReadonlyArray<Issue>;
+	}
+	/** The issue interface of the failure output. */
+	interface Issue {
+		/** The error message of the issue. */
+		readonly message: string;
+		/** The path of the issue, if any. */
+		readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+	}
+	/** The path segment interface of the issue. */
+	interface PathSegment {
+		/** The key representing a path segment. */
+		readonly key: PropertyKey;
+	}
+	/** The Standard types interface. */
+	interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {
+	}
+	/** Infers the input type of a Standard. */
+	type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+	/** Infers the output type of a Standard. */
+	type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+	/** ArkType-specific properties that extend the standard schema with JSON Schema support. */
+	interface ArkTypeProps<Input = unknown, Output = Input> extends Props<Input, Output>, StandardJSONSchemaV1.Props<Input, Output> {
+		vendor: "arktype";
+	}
+}
+/** The Standard JSON Schema interface. */
+export interface StandardJSONSchemaV1<Input = unknown, Output = Input> {
+	/** The Standard JSON Schema properties. */
+	readonly "~standard": StandardJSONSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardJSONSchemaV1 {
+	/** The Standard JSON Schema properties interface. */
+	interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+		/** Methods for generating the input/output JSON Schema. */
+		readonly jsonSchema: StandardJSONSchemaV1.Converter;
+	}
+	/** The Standard JSON Schema converter interface. */
+	interface Converter {
+		/** Converts the input type to JSON Schema. May throw if conversion is not supported. */
+		readonly input: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
+		/** Converts the output type to JSON Schema. May throw if conversion is not supported. */
+		readonly output: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
+	}
+	/**
+	 * The target version of the generated JSON Schema.
+	 *
+	 * It is *strongly recommended* that implementers support `"draft-2020-12"` and `"draft-07"`, as they are both in wide use. All other targets can be implemented on a best-effort basis. Libraries should throw if they don't support a specified target.
+	 *
+	 * The `"openapi-3.0"` target is intended as a standardized specifier for OpenAPI 3.0 which is a superset of JSON Schema `"draft-04"`.
+	 */
+	type Target = "draft-2020-12" | "draft-07" | "openapi-3.0" | ({} & string);
+	/** The options for the input/output methods. */
+	interface Options {
+		/** Specifies the target version of the generated JSON Schema. Support for all versions is on a best-effort basis. If a given version is not supported, the library should throw. */
+		readonly target: Target;
+		/** Explicit support for additional vendor-specific parameters, if needed. */
+		readonly libraryOptions?: Record<string, unknown> | undefined;
+	}
+	/** The Standard types interface. */
+	interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {
+	}
+	/** Infers the input type of a Standard. */
+	type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+	/** Infers the output type of a Standard. */
+	type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+}
+export interface Schema<T = unknown> extends StandardSchemaV1<unknown, T> {
+}
+export type RouteModel<R = unknown, B = unknown, S = unknown, P = unknown> = {
+	response?: Schema<R>;
+	body?: Schema<B>;
+	search?: Schema<S>;
+	params?: Schema<P>;
+};
+/**
+ * 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.
+ * */
+export declare class Route<Path extends string = string, R = unknown, B = unknown, S = unknown, P = unknown> extends RouteAbstract<Path, R, B, S, P> implements RouteInterface<Path, R, B, S, P> {
+	protected readonly definition: RouteDefinition<Path>;
+	readonly handler: RouteHandler<R, B, S, P>;
+	constructor(definition: RouteDefinition<Path>, handler: RouteHandler<R, B, S, P>, model?: RouteModel<R, B, S, P>);
+	variant: RouteVariant;
+	endpoint: Path;
+	method: Method;
+	pattern: RegExp;
+	id: RouteId;
+	static makeRouteId(method: string, endpoint: string): RouteId;
+}
+/**
+ * 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> extends RouteAbstract<Path, HttpResponseInterface<string>> implements RouteInterface<Path, HttpResponseInterface<string>> {
+	private filePath;
+	constructor(path: Path, filePath: string, extension?: OrString<"html" | "css" | "js" | "ts">);
+	extension: string;
+	id: RouteId;
+	variant: RouteVariant;
+	method: Method;
+	endpoint: Path;
+	pattern: RegExp;
+	handler: RouteHandler<HttpResponseInterface<string>>;
+	private handleHtml;
+	private handleCss;
+	private handleJs;
+	private handleTs;
+	private handleFile;
+	private getFileName;
+	private getContent;
+	private toResponse;
+	private mimeTypes;
+}
+export interface ControllerInterface {
+	routeIds: Set<RouteId>;
+}
+export type MiddlewareHandler = (context: ContextInterface) => MaybePromise<void>;
+export type ControllerOptions = {
+	prefix?: string;
+	beforeEach?: MiddlewareHandler;
+};
+/** Extend this class to create your own controllers. */
+declare abstract class ControllerAbstract implements ControllerInterface {
+	constructor(opts?: ControllerOptions);
+	routeIds: Set<RouteId>;
+	protected prefix?: string;
+	protected beforeEach?: MiddlewareHandler;
+	protected route<Path extends string = string, B = unknown, R = unknown, S = unknown, P = unknown>(definition: RouteDefinition<Path>, handler: RouteHandler<B, R, S, P>, schemas?: RouteModel<B, R, S, P>): RouteInterface<Path, B, R, S, P>;
+	protected staticRoute<Path extends string = string>(path: Path, filePath: string, extension?: OrString<"html" | "css" | "js" | "ts">): RouteInterface<Path, HttpResponseInterface<string>>;
+}
+export type AnyRoute = RouteInterface<string, any, any, any, any>;
+export type MiddlewareUseOn = Array<AnyRoute | ControllerInterface> | AnyRoute | ControllerInterface | "*";
+export interface MiddlewareInterface {
+	useOn: MiddlewareUseOn;
+	handler: MiddlewareHandler;
+}
+export type MiddlewareOptions = {
+	useOn: MiddlewareUseOn;
+	handler: MiddlewareHandler;
+};
+/**
+ * Simple middleware that runs before the Route "callback" parameters.
+ * Manipulates context.
+ * */
+export declare class Middleware implements MiddlewareInterface {
+	constructor(opts: MiddlewareOptions);
+	useOn: MiddlewareUseOn;
+	handler: MiddlewareHandler;
+}
+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]["response"] extends Schema ? {
+		response: InferSchema<T[K]["response"]>;
+	} : {}) & (T[K]["params"] extends Schema ? {
+		params: InferSchema<T[K]["params"]>;
+	} : {}) & (T[K]["search"] extends Schema ? {
+		search: InferSchema<T[K]["search"]>;
+	} : {})> : T[K] extends Schema ? InferSchema<T[K]> : never;
+};
+export interface RepositoryInterface {
+	readonly db: DatabaseClientInterface;
+}
+/** Abstract class for repository implementations */
+declare abstract class RepositoryAbstract implements RepositoryInterface {
+	readonly db: DatabaseClientInterface;
+	constructor(db: DatabaseClientInterface);
+}
+
+declare namespace C {
+	export { CommonHeaders, Config, ControllerAbstract as Controller, ControllerInterface, Cookies, CookiesInterface, CorsOptions, HttpError as Error, HttpErrorInterface as ErrorInterface, HttpHeaders as Headers, HttpHeadersInterface as HeadersInterface, HttpRequest as Request, HttpRequestInterface as RequestInterface, HttpResponse as Response, HttpResponseInterface as ResponseInterface, InferModel, InferSchema, Method, Middleware, MiddlewareHandler, MiddlewareInterface, MiddlewareUseOn, RepositoryAbstract as Repository, Route, RouteInterface, Schema, Server, StaticRoute, Status };
+}
+
+export {
+	C,
+	C as default,
+	ControllerAbstract as Controller,
+	HttpError as Error,
+	HttpErrorInterface as ErrorInterface,
+	HttpHeaders as Headers,
+	HttpHeadersInterface as HeadersInterface,
+	HttpRequest as Request,
+	HttpRequestInterface as RequestInterface,
+	HttpResponse as Response,
+	HttpResponseInterface as ResponseInterface,
+	RepositoryAbstract as Repository,
+};
+
+export {};