@versori/run 0.0.1-alpha.2 → 0.0.1-alpha.4

package/script/deps/deno.land/x/oak@v17.1.4/response.js

@@ -0,0 +1,299 @@
+"use strict";
+// Copyright 2018-2025 the oak authors. All rights reserved. MIT license.
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _Response_instances, _Response_body, _Response_bodySet, _Response_domResponse, _Response_headers, _Response_jsonBodyReplacer, _Response_request, _Response_resources, _Response_status, _Response_type, _Response_writable, _Response_getBodyInit, _Response_setContentType;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Response = exports.REDIRECT_BACK = void 0;
+/**
+ * Contains the {@linkcode Response} abstraction used by oak.
+ *
+ * Most end users would not need to directly access this module.
+ *
+ * @module
+ */
+const deps_js_1 = require("./deps.js");
+const http_server_native_request_js_1 = require("./http_server_native_request.js");
+const type_guards_js_1 = require("./utils/type_guards.js");
+const consts_js_1 = require("./utils/consts.js");
+const encode_url_js_1 = require("./utils/encode_url.js");
+const streams_js_1 = require("./utils/streams.js");
+/** A symbol that indicates to `response.redirect()` to attempt to redirect
+ * back to the request referrer.  For example:
+ *
+ * ```ts
+ * import { Application, REDIRECT_BACK } from "jsr:@oak/oak/";
+ *
+ * const app = new Application();
+ *
+ * app.use((ctx) => {
+ *   if (ctx.request.url.pathName === "/back") {
+ *     ctx.response.redirect(REDIRECT_BACK, "/");
+ *   }
+ * });
+ *
+ * await app.listen({ port: 80 });
+ * ```
+ */
+exports.REDIRECT_BACK = Symbol("redirect backwards");
+async function convertBodyToBodyInit(body, type, jsonBodyReplacer) {
+    let result;
+    if (consts_js_1.BODY_TYPES.includes(typeof body)) {
+        result = String(body);
+        type = type ?? ((0, type_guards_js_1.isHtml)(result) ? "html" : "text/plain");
+    }
+    else if ((0, type_guards_js_1.isFsFile)(body)) {
+        result = body.readable;
+    }
+    else if (ArrayBuffer.isView(body) || body instanceof ArrayBuffer ||
+        body instanceof Blob || body instanceof URLSearchParams) {
+        // deno-lint-ignore no-explicit-any
+        result = body;
+    }
+    else if (body instanceof ReadableStream) {
+        result = body.pipeThrough(new streams_js_1.Uint8ArrayTransformStream());
+    }
+    else if (body instanceof FormData) {
+        result = body;
+        type = undefined;
+    }
+    else if ((0, type_guards_js_1.isAsyncIterable)(body)) {
+        result = (0, streams_js_1.readableStreamFromAsyncIterable)(body);
+    }
+    else if (body && typeof body === "object") {
+        result = JSON.stringify(body, jsonBodyReplacer);
+        type = type ?? "json";
+    }
+    else if (typeof body === "function") {
+        const result = body.call(null);
+        return convertBodyToBodyInit(await result, type, jsonBodyReplacer);
+    }
+    else if (body) {
+        throw new TypeError("Response body was set but could not be converted.");
+    }
+    return [result, type];
+}
+/** An interface to control what response will be sent when the middleware
+ * finishes processing the request.
+ *
+ * The response is usually accessed via the context's `.response` property.
+ *
+ * ### Example
+ *
+ * ```ts
+ * import { Application, Status } from "jsr:@oak/oak/";
+ *
+ * const app = new Application();
+ *
+ * app.use((ctx) => {
+ *   ctx.response.body = { hello: "oak" };
+ *   ctx.response.type = "json";
+ *   ctx.response.status = Status.OK;
+ * });
+ * ```
+ */
+class Response {
+    /** The body of the response.  The body will be automatically processed when
+     * the response is being sent and converted to a `Uint8Array` or a
+     * `Deno.Reader`.
+     *
+     * Automatic conversion to a `Deno.Reader` occurs for async iterables. */
+    get body() {
+        return __classPrivateFieldGet(this, _Response_body, "f");
+    }
+    /** The body of the response.  The body will be automatically processed when
+     * the response is being sent and converted to a `Uint8Array` or a
+     * `Deno.Reader`.
+     *
+     * Automatic conversion to a `Deno.Reader` occurs for async iterables. */
+    set body(value) {
+        if (!__classPrivateFieldGet(this, _Response_writable, "f")) {
+            throw new Error("The response is not writable.");
+        }
+        __classPrivateFieldSet(this, _Response_bodySet, true, "f");
+        __classPrivateFieldSet(this, _Response_body, value, "f");
+    }
+    /** Headers that will be returned in the response. */
+    get headers() {
+        return __classPrivateFieldGet(this, _Response_headers, "f");
+    }
+    /** Headers that will be returned in the response. */
+    set headers(value) {
+        if (!__classPrivateFieldGet(this, _Response_writable, "f")) {
+            throw new Error("The response is not writable.");
+        }
+        __classPrivateFieldSet(this, _Response_headers, value, "f");
+    }
+    /** The HTTP status of the response.  If this has not been explicitly set,
+     * reading the value will return what would be the value of status if the
+     * response were sent at this point in processing the middleware.  If the body
+     * has been set, the status will be `200 OK`.  If a value for the body has
+     * not been set yet, the status will be `404 Not Found`. */
+    get status() {
+        if (__classPrivateFieldGet(this, _Response_status, "f")) {
+            return __classPrivateFieldGet(this, _Response_status, "f");
+        }
+        return this.body != null
+            ? deps_js_1.Status.OK
+            : __classPrivateFieldGet(this, _Response_bodySet, "f")
+                ? deps_js_1.Status.NoContent
+                : deps_js_1.Status.NotFound;
+    }
+    /** The HTTP status of the response.  If this has not been explicitly set,
+     * reading the value will return what would be the value of status if the
+     * response were sent at this point in processing the middleware.  If the body
+     * has been set, the status will be `200 OK`.  If a value for the body has
+     * not been set yet, the status will be `404 Not Found`. */
+    set status(value) {
+        if (!__classPrivateFieldGet(this, _Response_writable, "f")) {
+            throw new Error("The response is not writable.");
+        }
+        __classPrivateFieldSet(this, _Response_status, value, "f");
+    }
+    /** The media type, or extension of the response.  Setting this value will
+     * ensure an appropriate `Content-Type` header is added to the response. */
+    get type() {
+        return __classPrivateFieldGet(this, _Response_type, "f");
+    }
+    /** The media type, or extension of the response.  Setting this value will
+     * ensure an appropriate `Content-Type` header is added to the response. */
+    set type(value) {
+        if (!__classPrivateFieldGet(this, _Response_writable, "f")) {
+            throw new Error("The response is not writable.");
+        }
+        __classPrivateFieldSet(this, _Response_type, value, "f");
+    }
+    /** A read-only property which determines if the response is writable or not.
+     * Once the response has been processed, this value is set to `false`. */
+    get writable() {
+        return __classPrivateFieldGet(this, _Response_writable, "f");
+    }
+    constructor(request, jsonBodyReplacer) {
+        _Response_instances.add(this);
+        _Response_body.set(this, void 0);
+        _Response_bodySet.set(this, false);
+        _Response_domResponse.set(this, void 0);
+        _Response_headers.set(this, new Headers());
+        _Response_jsonBodyReplacer.set(this, void 0);
+        _Response_request.set(this, void 0);
+        _Response_resources.set(this, []);
+        _Response_status.set(this, void 0);
+        _Response_type.set(this, void 0);
+        _Response_writable.set(this, true);
+        __classPrivateFieldSet(this, _Response_request, request, "f");
+        __classPrivateFieldSet(this, _Response_jsonBodyReplacer, jsonBodyReplacer, "f");
+    }
+    /** Add a resource to the list of resources that will be closed when the
+     * request is destroyed. */
+    addResource(resource) {
+        __classPrivateFieldGet(this, _Response_resources, "f").push(resource);
+    }
+    /** Release any resources that are being tracked by the response.
+     *
+     * @param closeResources close any resource IDs registered with the response
+     */
+    destroy(closeResources = true) {
+        __classPrivateFieldSet(this, _Response_writable, false, "f");
+        __classPrivateFieldSet(this, _Response_body, undefined, "f");
+        __classPrivateFieldSet(this, _Response_domResponse, undefined, "f");
+        if (closeResources) {
+            for (const resource of __classPrivateFieldGet(this, _Response_resources, "f")) {
+                try {
+                    resource.close();
+                }
+                catch {
+                    // we don't care about errors here
+                }
+            }
+        }
+    }
+    redirect(url, alt = "/") {
+        if (url === exports.REDIRECT_BACK) {
+            url = __classPrivateFieldGet(this, _Response_request, "f").headers.get("Referer") ?? String(alt);
+        }
+        else if (typeof url === "object") {
+            url = String(url);
+        }
+        this.headers.set("Location", (0, encode_url_js_1.encodeUrl)(url));
+        if (!this.status || !(0, deps_js_1.isRedirectStatus)(this.status)) {
+            this.status = deps_js_1.Status.Found;
+        }
+        if (__classPrivateFieldGet(this, _Response_request, "f").accepts("html")) {
+            url = encodeURI(url);
+            this.type = "text/html; charset=UTF-8";
+            this.body = `Redirecting to <a href="${url}">${url}</a>.`;
+            return;
+        }
+        this.type = "text/plain; charset=UTF-8";
+        this.body = `Redirecting to ${url}.`;
+    }
+    async toDomResponse() {
+        if (__classPrivateFieldGet(this, _Response_domResponse, "f")) {
+            return __classPrivateFieldGet(this, _Response_domResponse, "f");
+        }
+        const bodyInit = await __classPrivateFieldGet(this, _Response_instances, "m", _Response_getBodyInit).call(this);
+        __classPrivateFieldGet(this, _Response_instances, "m", _Response_setContentType).call(this);
+        const { headers } = this;
+        // If there is no body and no content type and no set length, then set the
+        // content length to 0
+        if (!(bodyInit ||
+            headers.has("Content-Type") ||
+            headers.has("Content-Length"))) {
+            headers.append("Content-Length", "0");
+        }
+        __classPrivateFieldSet(this, _Response_writable, false, "f");
+        const status = this.status;
+        const responseInit = {
+            headers,
+            status,
+            statusText: deps_js_1.STATUS_TEXT[status],
+        };
+        return __classPrivateFieldSet(this, _Response_domResponse, new http_server_native_request_js_1.DomResponse(bodyInit, responseInit), "f");
+    }
+    with(responseOrBody, init) {
+        if (__classPrivateFieldGet(this, _Response_domResponse, "f") || !__classPrivateFieldGet(this, _Response_writable, "f")) {
+            throw new Error("A response has already been finalized.");
+        }
+        __classPrivateFieldSet(this, _Response_writable, false, "f");
+        __classPrivateFieldSet(this, _Response_domResponse, responseOrBody instanceof http_server_native_request_js_1.DomResponse
+            ? responseOrBody
+            : new http_server_native_request_js_1.DomResponse(responseOrBody, init), "f");
+    }
+    [(_Response_body = new WeakMap(), _Response_bodySet = new WeakMap(), _Response_domResponse = new WeakMap(), _Response_headers = new WeakMap(), _Response_jsonBodyReplacer = new WeakMap(), _Response_request = new WeakMap(), _Response_resources = new WeakMap(), _Response_status = new WeakMap(), _Response_type = new WeakMap(), _Response_writable = new WeakMap(), _Response_instances = new WeakSet(), _Response_getBodyInit = async function _Response_getBodyInit() {
+        const [body, type] = await convertBodyToBodyInit(this.body, this.type, __classPrivateFieldGet(this, _Response_jsonBodyReplacer, "f"));
+        this.type = type;
+        return body;
+    }, _Response_setContentType = function _Response_setContentType() {
+        if (this.type) {
+            const contentTypeString = (0, deps_js_1.contentType)(this.type);
+            if (contentTypeString && !this.headers.has("Content-Type")) {
+                this.headers.append("Content-Type", contentTypeString);
+            }
+        }
+    }, Symbol.for("Deno.customInspect"))](inspect) {
+        const { body, headers, status, type, writable } = this;
+        return `${this.constructor.name} ${inspect({ body, headers, status, type, writable })}`;
+    }
+    [Symbol.for("nodejs.util.inspect.custom")](depth, 
+    // deno-lint-ignore no-explicit-any
+    options, inspect) {
+        if (depth < 0) {
+            return options.stylize(`[${this.constructor.name}]`, "special");
+        }
+        const newOptions = Object.assign({}, options, {
+            depth: options.depth === null ? null : options.depth - 1,
+        });
+        const { body, headers, status, type, writable } = this;
+        return `${options.stylize(this.constructor.name, "special")} ${inspect({ body, headers, status, type, writable }, newOptions)}`;
+    }
+}
+exports.Response = Response;

package/script/deps/deno.land/x/oak@v17.1.4/router.d.ts

@@ -0,0 +1,363 @@
+/**
+ * Contains the router of oak. Typical usage is the creation of an application
+ * instance, the creation of a router instance, registration of route
+ * middleware, registration of router with the application, and then starting to
+ * listen for requests.
+ *
+ * # Example
+ *
+ * ```ts
+ * import { Application } from "jsr:@oak/oak/application";
+ * import { Router } from "jsr:@oak/oak/router";
+ *
+ * const app = new Application();
+ * const router = new Router();
+ * router.get("/", (ctx) => {
+ *   ctx.response.body = "hello world!";
+ * });
+ * app.use(router.routes());
+ * app.use(router.allowedMethods());
+ *
+ * app.listen();
+ * ```
+ *
+ * @module
+ */
+/**
+ * Adapted directly from @koa/router at
+ * https://github.com/koajs/router/ which is licensed as:
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015 Alexander C. Mingoia
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+import type { State } from "./application.js";
+import type { Context } from "./context.js";
+import { type HTTPMethods, type ParseOptions, type RedirectStatus, type TokensToRegexpOptions } from "./deps.js";
+import { type Middleware } from "./middleware.js";
+/** Options which can be specified when calling the `.allowedMethods()` method
+ * on a {@linkcode Router} instance. */
+export interface RouterAllowedMethodsOptions {
+    /** Use the value returned from this function instead of an HTTP error
+     * `MethodNotAllowed`. */
+    methodNotAllowed?(): any;
+    /** Use the value returned from this function instead of an HTTP error
+     * `NotImplemented`. */
+    notImplemented?(): any;
+    /** When dealing with a non-implemented method or a method not allowed, throw
+     * an error instead of setting the status and header for the response. */
+    throw?: boolean;
+}
+/** The internal abstraction of a route used by the oak {@linkcode Router}. */
+export interface Route<R extends string, P extends RouteParams<R> = RouteParams<R>, S extends State = Record<string, any>> {
+    /** The HTTP methods that this route handles. */
+    methods: HTTPMethods[];
+    /** The middleware that will be applied to this route. */
+    middleware: RouterMiddleware<R, P, S>[];
+    /** An optional name for the route. */
+    name?: string;
+    /** Options that were used to create the route. */
+    options: LayerOptions;
+    /** The parameters that are identified in the route that will be parsed out
+     * on matched requests. */
+    paramNames: (keyof P)[];
+    /** The path that this route manages. */
+    path: string;
+    /** The regular expression used for matching and parsing parameters for the
+     * route. */
+    regexp: RegExp;
+}
+/** The context passed router middleware.  */
+export interface RouterContext<R extends string, P extends RouteParams<R> = RouteParams<R>, S extends State = Record<string, any>> extends Context<S> {
+    /** When matching the route, an array of the capturing groups from the regular
+     * expression. */
+    captures: string[];
+    /** The routes that were matched for this request. */
+    matched?: Layer<R, P, S>[];
+    /** Any parameters parsed from the route when matched. */
+    params: P;
+    /** A reference to the router instance. */
+    router: Router;
+    /** If the matched route has a `name`, the matched route name is provided
+     * here. */
+    routeName?: string;
+    /** Overrides the matched path for future route middleware, when a
+     * `routerPath` option is not defined on the `Router` options. */
+    routerPath?: string;
+}
+/** The interface that {@linkcode Router} middleware should adhere to. */
+export interface RouterMiddleware<R extends string, P extends RouteParams<R> = RouteParams<R>, S extends State = Record<string, any>> {
+    (context: RouterContext<R, P, S>, next: () => Promise<unknown>): Promise<unknown> | unknown;
+    /** For route parameter middleware, the `param` key for this parameter will
+     * be set. */
+    param?: keyof P;
+    router?: Router<any>;
+}
+/** Options which can be specified when creating a new instance of a
+ * {@linkcode Router}. */
+export interface RouterOptions {
+    /** Override the default set of methods supported by the router. */
+    methods?: HTTPMethods[];
+    /** Only handle routes where the requested path starts with the prefix. */
+    prefix?: string;
+    /** Override the `request.url.pathname` when matching middleware to run. */
+    routerPath?: string;
+    /** Determines if routes are matched in a case sensitive way.  Defaults to
+     * `false`. */
+    sensitive?: boolean;
+    /** Determines if routes are matched strictly, where the trailing `/` is not
+     * optional.  Defaults to `false`. */
+    strict?: boolean;
+}
+/** Middleware that will be called by the router when handling a specific
+ * parameter, which the middleware will be called when a request matches the
+ * route parameter. */
+export interface RouterParamMiddleware<R extends string, P extends RouteParams<R> = RouteParams<R>, S extends State = Record<string, any>> {
+    (param: string, context: RouterContext<R, P, S>, next: () => Promise<unknown>): Promise<unknown> | unknown;
+    router?: Router<any>;
+}
+interface ParamsDictionary {
+    [key: string]: string;
+}
+type RemoveTail<S extends string, Tail extends string> = S extends `${infer P}${Tail}` ? P : S;
+type GetRouteParams<S extends string> = RemoveTail<RemoveTail<RemoveTail<S, `/${string}`>, `-${string}`>, `.${string}`>;
+/** A dynamic type which attempts to determine the route params based on
+ * matching the route string. */
+export type RouteParams<Route extends string> = string extends Route ? ParamsDictionary : Route extends `${string}(${string}` ? ParamsDictionary : Route extends `${string}:${infer Rest}` ? (GetRouteParams<Rest> extends never ? ParamsDictionary : GetRouteParams<Rest> extends `${infer ParamName}?` ? {
+    [P in ParamName]?: string;
+} : {
+    [P in GetRouteParams<Rest>]: string;
+}) & (Rest extends `${GetRouteParams<Rest>}${infer Next}` ? RouteParams<Next> : unknown) : Record<string | number, string | undefined>;
+type LayerOptions = TokensToRegexpOptions & ParseOptions & {
+    ignoreCaptures?: boolean;
+    name?: string;
+};
+type UrlOptions = TokensToRegexpOptions & ParseOptions & {
+    /** When generating a URL from a route, add the query to the URL.  If an
+     * object */
+    query?: URLSearchParams | Record<string, string> | string;
+};
+/** An internal class used to group together middleware when using multiple
+ * middlewares with a router. */
+export declare class Layer<R extends string, P extends RouteParams<R> = RouteParams<R>, S extends State = Record<string, any>> {
+    #private;
+    methods: HTTPMethods[];
+    name?: string;
+    path: string;
+    stack: RouterMiddleware<R, P, S>[];
+    constructor(path: string, methods: HTTPMethods[], middleware: RouterMiddleware<R, P, S> | RouterMiddleware<R, P, S>[], { name, ...opts }?: LayerOptions);
+    clone(): Layer<R, P, S>;
+    match(path: string): boolean;
+    params(captures: string[], existingParams?: RouteParams<R>): RouteParams<R>;
+    captures(path: string): string[];
+    url(params?: RouteParams<R>, options?: UrlOptions): string;
+    param(param: string, fn: RouterParamMiddleware<any, any, any>): this;
+    setPrefix(prefix: string): this;
+    toJSON(): Route<any, any, any>;
+}
+/** An interface for registering middleware that will run when certain HTTP
+ * methods and paths are requested, as well as provides a way to parameterize
+ * parts of the requested path.
+ *
+ * ### Basic example
+ *
+ * ```ts
+ * import { Application, Router } from "jsr:@oak/oak/";
+ *
+ * const router = new Router();
+ * router.get("/", (ctx, next) => {
+ *   // handle the GET endpoint here
+ * });
+ * router.all("/item/:item", (ctx, next) => {
+ *   // called for all HTTP verbs/requests
+ *   ctx.params.item; // contains the value of `:item` from the parsed URL
+ * });
+ *
+ * const app = new Application();
+ * app.use(router.routes());
+ * app.use(router.allowedMethods());
+ *
+ * app.listen({ port: 8080 });
+ * ```
+ */
+export declare class Router<RS extends State = Record<string, any>> {
+    #private;
+    constructor(opts?: RouterOptions);
+    /** Register named middleware for the specified routes when specified methods
+     * are requested. */
+    add<R extends string, P extends RouteParams<R> = RouteParams<R>, S extends State = RS>(methods: HTTPMethods[] | HTTPMethods, name: string, path: R, middleware: RouterMiddleware<R, P, S>, ...middlewares: RouterMiddleware<R, P, S>[]): Router<S extends RS ? S : (S & RS)>;
+    /** Register middleware for the specified routes when the specified methods is
+     * requested. */
+    add<R extends string, P extends RouteParams<R> = RouteParams<R>, S extends State = RS>(methods: HTTPMethods[] | HTTPMethods, path: R, middleware: RouterMiddleware<R, P, S>, ...middlewares: RouterMiddleware<R, P, S>[]): Router<S extends RS ? S : (S & RS)>;
+    /** Register middleware for the specified routes when the specified methods
+     * are requested with explicit path parameters. */
+    add<P extends RouteParams<string>, S extends State = RS>(methods: HTTPMethods[] | HTTPMethods, nameOrPath: string, pathOrMiddleware: string | RouterMiddleware<string, P, S>, ...middleware: RouterMiddleware<string, P, S>[]): Router<S extends RS ? S : (S & RS)>;
+    /** Register named middleware for the specified routes when the `DELETE`,
+     * `GET`, `POST`, or `PUT` method is requested. */
+    all<R extends string, P extends RouteParams<R> = RouteParams<R>, S extends State = RS>(name: string, path: R, middleware: RouterMiddleware<R, P, S>, ...middlewares: RouterMiddleware<R, P, S>[]): Router<S extends RS ? S : (S & RS)>;
+    /** Register middleware for the specified routes when the `DELETE`,
+     * `GET`, `POST`, or `PUT` method is requested. */
+    all<R extends string, P extends RouteParams<R> = RouteParams<R>, S extends State = RS>(path: R, middleware: RouterMiddleware<R, P, S>, ...middlewares: RouterMiddleware<R, P, S>[]): Router<S extends RS ? S : (S & RS)>;
+    /** Register middleware for the specified routes when the `DELETE`,
+     * `GET`, `POST`, or `PUT` method is requested with explicit path parameters.
+     */
+    all<P extends RouteParams<string>, S extends State = RS>(nameOrPath: string, pathOrMiddleware: string | RouterMiddleware<string, P, S>, ...middleware: RouterMiddleware<string, P, S>[]): Router<S extends RS ? S : (S & RS)>;
+    /** Middleware that handles requests for HTTP methods registered with the
+     * router.  If none of the routes handle a method, then "not allowed" logic
+     * will be used.  If a method is supported by some routes, but not the
+     * particular matched router, then "not implemented" will be returned.
+     *
+     * The middleware will also automatically handle the `OPTIONS` method,
+     * responding with a `200 OK` when the `Allowed` header sent to the allowed
+     * methods for a given route.
+     *
+     * By default, a "not allowed" request will respond with a `405 Not Allowed`
+     * and a "not implemented" will respond with a `501 Not Implemented`. Setting
+     * the option `.throw` to `true` will cause the middleware to throw an
+     * `HTTPError` instead of setting the response status.  The error can be
+     * overridden by providing a `.notImplemented` or `.notAllowed` method in the
+     * options, of which the value will be returned will be thrown instead of the
+     * HTTP error. */
+    allowedMethods(options?: RouterAllowedMethodsOptions): Middleware;
+    /** Register named middleware for the specified routes when the `DELETE`,
+     *  method is requested. */
+    delete<R extends string, P extends RouteParams<R> = RouteParams<R>, S extends State = RS>(name: string, path: R, middleware: RouterMiddleware<R, P, S>, ...middlewares: RouterMiddleware<R, P, S>[]): Router<S extends RS ? S : (S & RS)>;
+    /** Register middleware for the specified routes when the `DELETE`,
+     * method is requested. */
+    delete<R extends string, P extends RouteParams<R> = RouteParams<R>, S extends State = RS>(path: R, middleware: RouterMiddleware<R, P, S>, ...middlewares: RouterMiddleware<R, P, S>[]): Router<S extends RS ? S : (S & RS)>;
+    /** Register middleware for the specified routes when the `DELETE`,
+     * method is requested with explicit path parameters. */
+    delete<P extends RouteParams<string>, S extends State = RS>(nameOrPath: string, pathOrMiddleware: string | RouterMiddleware<string, P, S>, ...middleware: RouterMiddleware<string, P, S>[]): Router<S extends RS ? S : (S & RS)>;
+    /** Iterate over the routes currently added to the router.  To be compatible
+     * with the iterable interfaces, both the key and value are set to the value
+     * of the route. */
+    entries(): IterableIterator<[Route<string>, Route<string>]>;
+    /** Iterate over the routes currently added to the router, calling the
+     * `callback` function for each value. */
+    forEach(callback: (value1: Route<string>, value2: Route<string>, router: this) => void, thisArg?: any): void;
+    /** Register named middleware for the specified routes when the `GET`,
+     *  method is requested. */
+    get<R extends string, P extends RouteParams<R> = RouteParams<R>, S extends State = RS>(name: string, path: R, middleware: RouterMiddleware<R, P, S>, ...middlewares: RouterMiddleware<R, P, S>[]): Router<S extends RS ? S : (S & RS)>;
+    /** Register middleware for the specified routes when the `GET`,
+     * method is requested. */
+    get<R extends string, P extends RouteParams<R> = RouteParams<R>, S extends State = RS>(path: R, middleware: RouterMiddleware<R, P, S>, ...middlewares: RouterMiddleware<R, P, S>[]): Router<S extends RS ? S : (S & RS)>;
+    /** Register middleware for the specified routes when the `GET`,
+     * method is requested with explicit path parameters. */
+    get<P extends RouteParams<string>, S extends State = RS>(nameOrPath: string, pathOrMiddleware: string | RouterMiddleware<string, P, S>, ...middleware: RouterMiddleware<string, P, S>[]): Router<S extends RS ? S : (S & RS)>;
+    /** Register named middleware for the specified routes when the `HEAD`,
+     *  method is requested. */
+    head<R extends string, P extends RouteParams<R> = RouteParams<R>, S extends State = RS>(name: string, path: R, middleware: RouterMiddleware<R, P, S>, ...middlewares: RouterMiddleware<R, P, S>[]): Router<S extends RS ? S : (S & RS)>;
+    /** Register middleware for the specified routes when the `HEAD`,
+     * method is requested. */
+    head<R extends string, P extends RouteParams<R> = RouteParams<R>, S extends State = RS>(path: R, middleware: RouterMiddleware<R, P, S>, ...middlewares: RouterMiddleware<R, P, S>[]): Router<S extends RS ? S : (S & RS)>;
+    /** Register middleware for the specified routes when the `HEAD`,
+     * method is requested with explicit path parameters. */
+    head<P extends RouteParams<string>, S extends State = RS>(nameOrPath: string, pathOrMiddleware: string | RouterMiddleware<string, P, S>, ...middleware: RouterMiddleware<string, P, S>[]): Router<S extends RS ? S : (S & RS)>;
+    /** Iterate over the routes currently added to the router.  To be compatible
+     * with the iterable interfaces, the key is set to the value of the route. */
+    keys(): IterableIterator<Route<string>>;
+    /** Register named middleware for the specified routes when the `OPTIONS`,
+     * method is requested. */
+    options<R extends string, P extends RouteParams<R> = RouteParams<R>, S extends State = RS>(name: string, path: R, middleware: RouterMiddleware<R, P, S>, ...middlewares: RouterMiddleware<R, P, S>[]): Router<S extends RS ? S : (S & RS)>;
+    /** Register middleware for the specified routes when the `OPTIONS`,
+     * method is requested. */
+    options<R extends string, P extends RouteParams<R> = RouteParams<R>, S extends State = RS>(path: R, middleware: RouterMiddleware<R, P, S>, ...middlewares: RouterMiddleware<R, P, S>[]): Router<S extends RS ? S : (S & RS)>;
+    /** Register middleware for the specified routes when the `OPTIONS`,
+     * method is requested with explicit path parameters. */
+    options<P extends RouteParams<string>, S extends State = RS>(nameOrPath: string, pathOrMiddleware: string | RouterMiddleware<string, P, S>, ...middleware: RouterMiddleware<string, P, S>[]): Router<S extends RS ? S : (S & RS)>;
+    /** Register param middleware, which will be called when the particular param
+     * is parsed from the route. */
+    param<R extends string, S extends State = RS>(param: keyof RouteParams<R>, middleware: RouterParamMiddleware<R, RouteParams<R>, S>): Router<S>;
+    /** Register named middleware for the specified routes when the `PATCH`,
+     * method is requested. */
+    patch<R extends string, P extends RouteParams<R> = RouteParams<R>, S extends State = RS>(name: string, path: R, middleware: RouterMiddleware<R, P, S>, ...middlewares: RouterMiddleware<R, P, S>[]): Router<S extends RS ? S : (S & RS)>;
+    /** Register middleware for the specified routes when the `PATCH`,
+     * method is requested. */
+    patch<R extends string, P extends RouteParams<R> = RouteParams<R>, S extends State = RS>(path: R, middleware: RouterMiddleware<R, P, S>, ...middlewares: RouterMiddleware<R, P, S>[]): Router<S extends RS ? S : (S & RS)>;
+    /** Register middleware for the specified routes when the `PATCH`,
+     * method is requested with explicit path parameters. */
+    patch<P extends RouteParams<string>, S extends State = RS>(nameOrPath: string, pathOrMiddleware: string | RouterMiddleware<string, P, S>, ...middleware: RouterMiddleware<string, P, S>[]): Router<S extends RS ? S : (S & RS)>;
+    /** Register named middleware for the specified routes when the `POST`,
+     * method is requested. */
+    post<R extends string, P extends RouteParams<R> = RouteParams<R>, S extends State = RS>(name: string, path: R, middleware: RouterMiddleware<R, P, S>, ...middlewares: RouterMiddleware<R, P, S>[]): Router<S extends RS ? S : (S & RS)>;
+    /** Register middleware for the specified routes when the `POST`,
+     * method is requested. */
+    post<R extends string, P extends RouteParams<R> = RouteParams<R>, S extends State = RS>(path: R, middleware: RouterMiddleware<R, P, S>, ...middlewares: RouterMiddleware<R, P, S>[]): Router<S extends RS ? S : (S & RS)>;
+    /** Register middleware for the specified routes when the `POST`,
+     * method is requested with explicit path parameters. */
+    post<P extends RouteParams<string>, S extends State = RS>(nameOrPath: string, pathOrMiddleware: string | RouterMiddleware<string, P, S>, ...middleware: RouterMiddleware<string, P, S>[]): Router<S extends RS ? S : (S & RS)>;
+    /** Set the router prefix for this router. */
+    prefix(prefix: string): this;
+    /** Register named middleware for the specified routes when the `PUT`
+     * method is requested. */
+    put<R extends string, P extends RouteParams<R> = RouteParams<R>, S extends State = RS>(name: string, path: R, middleware: RouterMiddleware<R, P, S>, ...middlewares: RouterMiddleware<R, P, S>[]): Router<S extends RS ? S : (S & RS)>;
+    /** Register middleware for the specified routes when the `PUT`
+     * method is requested. */
+    put<R extends string, P extends RouteParams<R> = RouteParams<R>, S extends State = RS>(path: R, middleware: RouterMiddleware<R, P, S>, ...middlewares: RouterMiddleware<R, P, S>[]): Router<S extends RS ? S : (S & RS)>;
+    /** Register middleware for the specified routes when the `PUT`
+     * method is requested with explicit path parameters. */
+    put<P extends RouteParams<string>, S extends State = RS>(nameOrPath: string, pathOrMiddleware: string | RouterMiddleware<string, P, S>, ...middleware: RouterMiddleware<string, P, S>[]): Router<S extends RS ? S : (S & RS)>;
+    /** Register a direction middleware, where when the `source` path is matched
+     * the router will redirect the request to the `destination` path.  A `status`
+     * of `302 Found` will be set by default.
+     *
+     * The `source` and `destination` can be named routes. */
+    redirect(source: string, destination: string | URL, status?: RedirectStatus): this;
+    /** Return middleware that will do all the route processing that the router
+     * has been configured to handle.  Typical usage would be something like this:
+     *
+     * ```ts
+     * import { Application, Router } from "jsr:@oak/oak/";
+     *
+     * const app = new Application();
+     * const router = new Router();
+     *
+     * // register routes
+     *
+     * app.use(router.routes());
+     * app.use(router.allowedMethods());
+     * await app.listen({ port: 80 });
+     * ```
+     */
+    routes(): Middleware;
+    /** Generate a URL pathname for a named route, interpolating the optional
+     * params provided.  Also accepts an optional set of options. */
+    url<P extends RouteParams<string> = RouteParams<string>>(name: string, params?: P, options?: UrlOptions): string | undefined;
+    /** Register middleware to be used on every matched route. */
+    use<P extends RouteParams<string> = RouteParams<string>, S extends State = RS>(middleware: RouterMiddleware<string, P, S>, ...middlewares: RouterMiddleware<string, P, S>[]): Router<S extends RS ? S : (S & RS)>;
+    /** Register middleware to be used on every route that matches the supplied
+     * `path`. */
+    use<R extends string, P extends RouteParams<R> = RouteParams<R>, S extends State = RS>(path: R, middleware: RouterMiddleware<R, P, S>, ...middlewares: RouterMiddleware<R, P, S>[]): Router<S extends RS ? S : (S & RS)>;
+    /** Register middleware to be used on every route that matches the supplied
+     * `path` with explicit path parameters. */
+    use<P extends RouteParams<string>, S extends State = RS>(path: string, middleware: RouterMiddleware<string, P, S>, ...middlewares: RouterMiddleware<string, P, S>[]): Router<S extends RS ? S : (S & RS)>;
+    use<P extends RouteParams<string> = RouteParams<string>, S extends State = RS>(path: string[], middleware: RouterMiddleware<string, P, S>, ...middlewares: RouterMiddleware<string, P, S>[]): Router<S extends RS ? S : (S & RS)>;
+    /** Iterate over the routes currently added to the router. */
+    values(): IterableIterator<Route<string, RouteParams<string>, RS>>;
+    /** Provide an iterator interface that iterates over the routes registered
+     * with the router. */
+    [Symbol.iterator](): IterableIterator<Route<string, RouteParams<string>, RS>>;
+    /** Generate a URL pathname based on the provided path, interpolating the
+     * optional params provided.  Also accepts an optional set of options. */
+    static url<R extends string>(path: R, params?: RouteParams<R>, options?: UrlOptions): string;
+}
+export {};
+//# sourceMappingURL=router.d.ts.map