@orieljs/http 0.1.0-alpha.1

package/dist/index.d.ts

@@ -0,0 +1,480 @@
+import { HttpRequest, CookieJar, Session, Container, RedirectResponse, HeadersInit, Redirector, UploadedFile, Rules, OrielError, ResponseFactory, BodyInit, UrlGenerator, HttpKernel, Application, MiddlewareClass, Middleware, Next, MiddlewareConfigurator, Router, ConfigRepository, ExceptionHandler, ExceptionsConfigurator, ConsoleKernel, Route } from '@orieljs/contracts';
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { ServiceProvider } from '@orieljs/support';
+
+/** Reads a request body into memory, refusing more than `limit` bytes (413), like PHP's post_max_size. */
+declare function readBody(raw: Request, limit: number | null): Promise<Uint8Array>;
+
+/** The current container, only when it is a request scope (the kernel binds HttpRequest there). */
+declare function requestScope(): Container | undefined;
+declare function currentRequest(): HttpRequest | undefined;
+/** The request's session, or undefined outside a request or when no Session provider is registered. */
+declare function optionalSession(): Session | undefined;
+declare function optionalCookieJar(): CookieJar | undefined;
+
+type ErrorsInput = Record<string, string | string[]> | {
+    toObject(): Record<string, string[]>;
+};
+/**
+ * Laravel's RedirectResponse. with()/withErrors()/withInput() flash to the request's Session immediately, like
+ * Laravel; without a bound Session (an API-only app) they are skipped silently.
+ */
+declare class HttpRedirectResponse implements RedirectResponse {
+    #private;
+    readonly targetUrl: string;
+    readonly status: number;
+    constructor(targetUrl: string, status?: number, headers?: HeadersInit);
+    with(key: string | Record<string, unknown>, value?: unknown): this;
+    /** Flashes `errors` as { [bag]: { field: string[] } }, keeping the other bags already flashed. */
+    withErrors(errors: ErrorsInput, bag?: string): this;
+    /** Flashes `input`, or the current request's input (files are never part of input()). */
+    withInput(input?: Record<string, unknown>): this;
+    /**
+     * Always a Set-Cookie header on this response (Laravel's RedirectResponse::withCookie). A bound CookieJar only
+     * supplies the defaults (path, domain, secure, same-site); queueing would lose the cookie outside the web group.
+     */
+    withCookie(name: string, value: string, minutes?: number): this;
+    header(name: string, value: string): this;
+    toResponse(): Response;
+}
+
+/** Laravel's Redirector. Stateless: the URL generator and session come from the current container. */
+declare class HttpRedirector implements Redirector {
+    to(path: string, status?: number, headers?: HeadersInit): HttpRedirectResponse;
+    route(name: string, parameters?: unknown, status?: number): HttpRedirectResponse;
+    back(fallback?: string, status?: number): HttpRedirectResponse;
+    /** Pulls url.intended from the session (put there by guest()), else goes to `fallback`. */
+    intended(fallback?: string, status?: number): HttpRedirectResponse;
+    away(url: string, status?: number): HttpRedirectResponse;
+    /** Remembers where a guest was going (a GET page, else the previous URL), then redirects to `path`. */
+    guest(path: string, status?: number): HttpRedirectResponse;
+    setIntendedUrl(url: string): void;
+    refresh(status?: number): HttpRedirectResponse;
+}
+
+declare function setClientAddress(request: Request, address: string | undefined): void;
+declare function clientAddress(request: Request): string | undefined;
+
+/** An uploaded file from a multipart body. store()/storeAs() go through the FilesystemManager. */
+declare class FormUploadedFile implements UploadedFile {
+    private readonly file;
+    readonly clientName: string;
+    readonly mimeType: string;
+    readonly size: number;
+    constructor(file: Blob & {
+        readonly name?: string;
+    });
+    /** Guessed from the MIME type, falling back to the client's extension (Laravel's extension()). */
+    extension(): string;
+    clientExtension(): string;
+    /** A random 40-character name with the guessed extension. */
+    hashName(): string;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    text(): Promise<string>;
+    stream(): ReadableStream<Uint8Array>;
+    store(directory: string, disk?: string): Promise<string>;
+    storeAs(directory: string, name: string, disk?: string): Promise<string>;
+}
+
+interface IncomingRequestOptions {
+    /** Proxy addresses whose X-Forwarded-* headers are believed: exact IPs, IPv4 CIDRs, or '*'. */
+    trustedProxies?: readonly string[];
+    /** Largest request body in bytes before a 413 (config http.max_body_size); null is unlimited. Default 8 MB. */
+    maxBodySize?: number | null;
+}
+/** Exact match, IPv4 CIDR ('10.0.0.0/8') or '*'. */
+declare function ipMatches(ip: string, patterns: readonly string[]): boolean;
+/**
+ * The HttpRequest implementation (Laravel's Illuminate\Http\Request). The kernel calls load() once, before any
+ * middleware, so every accessor below is synchronous.
+ *
+ * `http.max_body_size` applies to the bodies this class parses (JSON, urlencoded and multipart). A handler that reads
+ * `request.raw` directly bypasses it and must enforce its own limit.
+ */
+declare class IncomingRequest implements HttpRequest {
+    #private;
+    readonly raw: Request;
+    constructor(raw: Request, options?: IncomingRequestOptions);
+    /** Reads and parses the body (JSON, urlencoded or multipart) once, then applies method spoofing. */
+    load(): Promise<this>;
+    method(): string;
+    isMethod(method: string): boolean;
+    /** The scheme and host, honouring X-Forwarded-Proto/Host from trusted proxies. */
+    root(): string;
+    /** The URL without the query string or a trailing slash. */
+    url(): string;
+    fullUrl(): string;
+    /** 'posts/1', or '/' for the root. */
+    path(): string;
+    decodedPath(): string;
+    secure(): boolean;
+    /** request.is('admin/*'): wildcard match against the decoded path. */
+    is(...patterns: string[]): boolean;
+    routeIs(...names: string[]): boolean;
+    header(name: string): string | undefined;
+    header(name: string, defaultValue: string): string;
+    bearerToken(): string | undefined;
+    userAgent(): string | undefined;
+    /** The socket address, or the right-most untrusted X-Forwarded-For entry when the socket is a trusted proxy. */
+    ip(): string | undefined;
+    ajax(): boolean;
+    pjax(): boolean;
+    /** The first Accept type is JSON. */
+    wantsJson(): boolean;
+    /** Laravel: (ajax and not pjax and accepts anything) or wantsJson. */
+    expectsJson(): boolean;
+    /** The raw body text for JSON and urlencoded requests ('' otherwise; the raw stream stays unread for other types). */
+    content(): string;
+    query<T = unknown>(key?: string, defaultValue?: T): T;
+    /** Body wins over the query string (PHP's $body + $query). Files are not input. */
+    input<T = unknown>(key?: string, defaultValue?: T): T;
+    /** Input plus files (array_replace_recursive). */
+    all(): Record<string, unknown>;
+    only(...keys: Array<string | string[]>): Record<string, unknown>;
+    except(...keys: Array<string | string[]>): Record<string, unknown>;
+    has(...keys: Array<string | string[]>): boolean;
+    hasAny(...keys: Array<string | string[]>): boolean;
+    missing(...keys: Array<string | string[]>): boolean;
+    filled(key: string): boolean;
+    string(key: string, defaultValue?: string): string;
+    /** PHP's FILTER_VALIDATE_BOOLEAN: '1', 'true', 'on', 'yes' (any case) and true are true. */
+    boolean(key: string, defaultValue?: boolean): boolean;
+    /** PHP's intval: leading digits, else 0. */
+    integer(key: string, defaultValue?: number): number;
+    /** Adds or replaces top-level body values. */
+    merge(values: Record<string, unknown>): this;
+    /** Rewrites every scalar in the query and the body (TrimStrings and ConvertEmptyStringsToNull use this). */
+    transformInput(transform: (key: string, value: unknown) => unknown): this;
+    file(key: string): UploadedFile | undefined;
+    hasFile(key: string): boolean;
+    allFiles(): Record<string, unknown>;
+    cookie(name: string): string | undefined;
+    cookies(): Record<string, string>;
+    /** Replaces the parsed cookies (EncryptCookies calls this after decrypting). */
+    setCookies(cookies: Record<string, string>): void;
+    /** One route parameter (after model binding), or all of them. */
+    route<T = unknown>(key?: string): T;
+    session(): Session;
+    user<T = unknown>(guard?: string): T | undefined;
+    setUserResolver(resolver: (guard?: string) => unknown): void;
+    /** Validates all() through the ValidationFactory; throws its Validation error on failure. */
+    validate<T = Record<string, unknown>>(rules: Rules, messages?: Record<string, string>, attributes?: Record<string, string>): Promise<T>;
+}
+
+/** Helpers for request input: PHP-style bracket keys, safe cloning (no prototype pollution) and blank checks. */
+type Tree = Record<string, unknown>;
+/** 'user[name]' → ['user', 'name']; 'tags[]' → ['tags', '']; a malformed key stays whole. */
+declare function parseBracketKey(name: string): string[];
+/** Objects whose keys are exactly 0..n-1 become arrays, recursively (PHP arrays → JS lists). */
+declare function normalizeLists(value: unknown): unknown;
+/**
+ * Builds nested input from flat form entries, PHP style: 'user[name]', 'tags[]', 'a[b][]'.
+ * Keys containing __proto__/prototype/constructor are dropped.
+ */
+declare function fromEntries(entries: Iterable<readonly [string, unknown]>): Tree;
+/** Deep copy of parsed JSON without dangerous keys (JSON.parse creates an own "__proto__" property). */
+declare function sanitize(value: unknown): unknown;
+/** array_replace_recursive: `override` wins, nested plain objects merge. */
+declare function mergeRecursive(base: Tree, override: Tree): Tree;
+/** Laravel's blank(): null, undefined, whitespace-only strings, and empty arrays/objects. */
+declare function isBlank(value: unknown): boolean;
+/** Applies `transform(dottedKey, value)` to every scalar leaf, inside nested objects and lists; the result replaces the leaf. */
+declare function transformLeaves(tree: Tree, transform: (key: string, value: unknown) => unknown, prefix?: string): Tree;
+
+/** 'report.PDF' or 'pdf' → 'application/pdf'; unknown → 'application/octet-stream'. */
+declare function mimeFromExtension(pathOrExtension: string): string;
+/** 'image/jpeg; charset=…' → 'jpg'; unknown → undefined. */
+declare function extensionFromMime(type: string): string | undefined;
+
+/** Symfony's HttpException: abort(404), abort(403, 'Nope'). An empty message renders as the status text. */
+declare class HttpException extends Error implements OrielError {
+    readonly status: number;
+    readonly headers: Record<string, string>;
+    readonly kind: "Http";
+    readonly name = "HttpException";
+    constructor(status: number, message?: string, headers?: Record<string, string>);
+}
+/** Carries a ready Response out of deep code: abort(response). The handler returns it as is. */
+declare class HttpResponseException extends Error implements OrielError {
+    readonly response: Response;
+    readonly kind: "Http";
+    readonly name = "HttpResponseException";
+    readonly status: number;
+    constructor(response: Response);
+}
+/** Http's internal failures (not thrown by this package itself; used by the kernel and error rendering). */
+declare class HttpServerError extends Error implements OrielError {
+    readonly kind: "Server";
+    readonly status = 500;
+    readonly name = "HttpServerError";
+}
+
+/** request() → the current HttpRequest; request('key', default) → its input. */
+declare function request(): HttpRequest;
+declare function request<T = unknown>(key: string, defaultValue?: T): T;
+/** response() → the ResponseFactory; response(content, status, headers) → a Response. */
+declare function response(): ResponseFactory;
+declare function response(content: BodyInit | null, status?: number, headers?: HeadersInit): Response;
+/** redirect() → the Redirector; redirect('/path', status) → a RedirectResponse. */
+declare function redirect(): Redirector;
+declare function redirect(to: string, status?: number): RedirectResponse;
+/** Redirect to the previous URL (same argument order as Redirector.back()). */
+declare function back(fallback?: string, status?: number): RedirectResponse;
+/** url() → the UrlGenerator; url('/path', query, absolute) → a URL. */
+declare function url(): UrlGenerator;
+declare function url(path: string, query?: Record<string, unknown>, absolute?: boolean): string;
+/** The URL of a named route. */
+declare function route(name: string, parameters?: unknown, absolute?: boolean): string;
+/** abort(404), abort(403, 'Nope', headers), or abort(response) to send a ready response. */
+declare function abort(status: number | Response, message?: string, headers?: Record<string, string>): never;
+declare function abortIf(condition: unknown, status: number | Response, message?: string, headers?: Record<string, string>): void;
+declare function abortUnless(condition: unknown, status: number | Response, message?: string, headers?: Record<string, string>): void;
+
+/** 'attachment; filename="report.pdf"' plus filename* for non-ASCII names (RFC 6266). */
+declare function contentDisposition(type: 'attachment' | 'inline', name: string): string;
+/** Laravel's ResponseFactory (the response() helper). */
+declare class HttpResponseFactory implements ResponseFactory {
+    #private;
+    /** Strings default to text/html; charset=utf-8, as in Laravel. */
+    make(content?: BodyInit | null, status?: number, headers?: HeadersInit): Response;
+    json(data: unknown, status?: number, headers?: HeadersInit): Response;
+    noContent(status?: number): Response;
+    /** Renders a view (through the ViewFactory) into an HTML response. */
+    view(name: string, data?: Record<string, unknown>, status?: number, headers?: HeadersInit): Promise<Response>;
+    /** Streams a file as an attachment. A missing file is a 404. */
+    download(path: string, name?: string, headers?: HeadersInit): Promise<Response>;
+    /** Streams a file for the browser to display (Laravel's response()->file()). */
+    file(path: string, headers?: HeadersInit): Promise<Response>;
+    stream(body: ReadableStream, status?: number, headers?: HeadersInit): Response;
+}
+
+/**
+ * Laravel's Http Kernel: wraps the raw Request, binds it in the request scope, loads the body, then sends it through
+ * the global middleware to the router. Every stage renders its own errors through the ExceptionHandler.
+ */
+declare class Kernel implements HttpKernel {
+    #private;
+    protected readonly app: Application;
+    constructor(app: Application);
+    getGlobalMiddleware(): MiddlewareClass[];
+    setGlobalMiddleware(middleware: MiddlewareClass[]): this;
+    appendMiddleware(...middleware: MiddlewareClass[]): this;
+    prependMiddleware(...middleware: MiddlewareClass[]): this;
+    hasMiddleware(middleware: MiddlewareClass): boolean;
+    /** Runs in the current request scope (Application.handle() opens one); called directly, it opens its own. */
+    handle(raw: Request): Promise<Response>;
+    /** Runs terminate() on the global and route middleware (inside the request's scope), then Application.terminate(), inside the same scope, so terminating callbacks see the request's bindings. */
+    terminate(raw: Request, response: Response): Promise<void>;
+}
+
+/** '' becomes null in the query and body, so `nullable` validation behaves as in Laravel. */
+declare class ConvertEmptyStringsToNull implements Middleware {
+    handle(request: HttpRequest, next: Next): Promise<Response>;
+}
+
+/** Trims every string in the query and body, except password fields (Laravel's TrimStrings). */
+declare class TrimStrings implements Middleware {
+    /** Dotted input keys left untouched. Override in a subclass to change. */
+    protected except: string[];
+    handle(request: HttpRequest, next: Next): Promise<Response>;
+}
+
+interface GroupOptions {
+    append?: MiddlewareClass[];
+    prepend?: MiddlewareClass[];
+    remove?: MiddlewareClass[];
+}
+/** The `m` in withMiddleware((m) => …): edits the kernel's global middleware and the router's groups and aliases. */
+declare class MiddlewareConfiguration implements MiddlewareConfigurator {
+    #private;
+    private readonly kernel;
+    private readonly router;
+    private readonly config?;
+    constructor(kernel: Kernel, router: Router, config?: ConfigRepository | undefined);
+    append(...middleware: MiddlewareClass[]): this;
+    prepend(...middleware: MiddlewareClass[]): this;
+    web(options: GroupOptions): this;
+    api(options: GroupOptions): this;
+    alias(aliases: Record<string, MiddlewareClass>): this;
+    group(name: string, middleware: Array<MiddlewareClass | string>): this;
+    /** Stored in config('http.csrf_except'), which the Session component's VerifyCsrfToken reads. */
+    validateCsrfTokens(options: {
+        except: string[];
+    }): this;
+    /** Stored in config('http.redirect_guests_to'), which the Auth middleware and the exception handler read. */
+    redirectGuestsTo(url: string | ((request: HttpRequest) => string)): this;
+    /** Laravel 11's redirectUsersTo(): stored in config('http.redirect_users_to') for Auth's RedirectIfAuthenticated. */
+    redirectUsersTo(url: string | ((request: HttpRequest) => string)): this;
+}
+/** Runs the withMiddleware() callbacks collected by the ApplicationBuilder (HttpServiceProvider calls this once booted). */
+declare function applyMiddlewareCallbacks(app: Application, kernel: Kernel): void;
+
+type ReportCallback = (error: unknown) => void | boolean | Promise<void | boolean>;
+type RenderCallback = (error: unknown, request: unknown) => Response | undefined | Promise<Response | undefined>;
+type ErrorClass = abstract new (...args: never[]) => Error;
+/** HTTP status for an error (spec §7). */
+declare function statusFor(error: unknown): number;
+/** "The title field is required. (and 2 more errors)" (Laravel's ValidationException::summarize). */
+declare function summarizeValidation(errors: Record<string, string[]>): string;
+/** The exception handler (spec §7): report through the LogManager, render by error kind. */
+declare class ErrorHandler implements ExceptionHandler {
+    #private;
+    protected readonly app: Application;
+    /** Input keys never flashed back on a validation redirect. */
+    protected dontFlash: string[];
+    constructor(app: Application);
+    reportUsing(callback: ReportCallback): void;
+    renderUsing(callback: RenderCallback): void;
+    ignore(...classes: ErrorClass[]): void;
+    shouldReport(error: unknown): boolean;
+    /** Report callbacks first (returning false stops the default log), then LogManager.error(), else console.error. Once per error. */
+    report(error: unknown): Promise<void>;
+    render(request: unknown, error: unknown): Promise<Response>;
+}
+
+/** The `e` in withExceptions((e) => …). */
+declare class ExceptionsConfiguration implements ExceptionsConfigurator {
+    private readonly handler;
+    constructor(handler: ErrorHandler);
+    report(callback: ReportCallback): this;
+    render(callback: RenderCallback): this;
+    dontReport(...classes: ErrorClass[]): this;
+}
+/** Runs the withExceptions() callbacks against a handler (the provider does this when the handler is built). */
+declare function applyExceptionCallbacks(app: Application, handler: ErrorHandler): void;
+
+/** Laravel's wording for the status (its error pages say "Server Error" and "Page Expired"). */
+declare function statusText(status: number): string;
+declare function escapeHtml(value: string): string;
+/** Laravel's minimal error page: "404 | Not Found". */
+declare function minimalPage(status: number, message: string): string;
+interface StackFrame {
+    readonly file: string;
+    readonly line: number;
+    readonly column: number;
+    readonly text: string;
+}
+/** Parses V8/JavaScriptCore stack lines into frames that point at files. */
+declare function stackFrames(error: Error): StackFrame[];
+/** The APP_DEBUG page: class, message, request, a source excerpt of the first app frame, the stack and causes. */
+declare function debugPage(error: unknown, method: string, url: string): Promise<string>;
+
+type Runtime = 'node' | 'bun';
+interface ServeOptions {
+    /** Default: PORT, then SERVER_PORT, then 8000 (Laravel's serve). 0 picks a free port. */
+    port?: number;
+    /** Default: 127.0.0.1. */
+    hostname?: string;
+    /** Close gracefully on SIGINT/SIGTERM, then exit. Default: true. */
+    signals?: boolean;
+    /** How long close() waits for in-flight requests before cutting connections (ms). Default: 10000. */
+    shutdownTimeout?: number;
+    /** Default: detected (Bun when globalThis.Bun exists). */
+    runtime?: Runtime;
+    /** Called once listening. Default: prints "Server running on [url]." */
+    onListen?: (server: RunningServer) => void;
+}
+interface ResolvedServeOptions {
+    readonly port: number;
+    readonly hostname: string;
+    readonly signals: boolean;
+    readonly shutdownTimeout: number;
+}
+interface RunningServer {
+    readonly runtime: Runtime;
+    readonly hostname: string;
+    readonly port: number;
+    /** 'http://127.0.0.1:8000' */
+    readonly url: string;
+    /** Stops accepting connections, waits for in-flight requests (up to shutdownTimeout), then resolves. */
+    close(): Promise<void>;
+    /** Resolves once the server has closed. */
+    readonly closed: Promise<void>;
+}
+
+/** The slice of Bun's API used here (typed locally: there is no Bun lib in the build). */
+interface BunServer {
+    readonly port: number;
+    stop(closeActiveConnections?: boolean): Promise<void> | void;
+    requestIP(request: Request): {
+        address: string;
+    } | null;
+}
+interface BunRuntime {
+    serve(options: {
+        port: number;
+        hostname: string;
+        fetch(request: Request, server: BunServer): Promise<Response>;
+        error(error: Error): Response;
+    }): BunServer;
+}
+declare function bunRuntime(): BunRuntime | undefined;
+declare function serveBun(app: Application, options: ResolvedServeOptions): Promise<RunningServer>;
+
+/** node:http IncomingMessage → web Request (the body streams; the signal aborts when the client goes away). */
+declare function toWebRequest(req: IncomingMessage, res: ServerResponse, fallbackHost: string): Request;
+/** Web Response → ServerResponse, streaming the body with backpressure. Several Set-Cookie headers stay separate. */
+declare function writeResponse(res: ServerResponse, response: Response): Promise<void>;
+declare function serveNode(app: Application, options: ResolvedServeOptions): Promise<RunningServer>;
+
+declare function detectRuntime(): Runtime;
+/** Boots the app and serves it with node:http or Bun.serve (public/index.ts: `await serve(app)`). */
+declare function serve(app: Application, options?: ServeOptions): Promise<RunningServer>;
+
+interface RouteListRow {
+    /** 'GET|HEAD' */
+    readonly method: string;
+    readonly uri: string;
+    readonly name: string | null;
+    /** 'PostController@show' or 'Closure' */
+    readonly action: string;
+    readonly middleware: string[];
+}
+/** One row per route, sorted by URI (Laravel's default --sort=uri; ties keep registration order). */
+declare function routeListRows(routes: readonly Route[]): RouteListRow[];
+interface RouteListFilters {
+    method?: string;
+    name?: string;
+    path?: string;
+    /** Comma-separated. */
+    exceptPath?: string;
+}
+/** Laravel's RouteListCommand::filterRoute: substring matches, method compared uppercased. */
+declare function filterRouteList(rows: readonly RouteListRow[], filters: RouteListFilters): RouteListRow[];
+/**
+ * Laravel's route:list layout: the method column padded, the URI, a dotted leader, then `name › action`
+ * (closures show only the name), and a right-aligned "Showing [n] routes" footer.
+ */
+declare function formatRouteList(rows: readonly RouteListRow[], width: number): string[];
+/** The routes/api.ts that install:api writes (Laravel's api.stub, with the token guard). */
+declare const API_ROUTES_STUB = "import { request, Route } from '@orieljs/framework'\n\nRoute.get('/user', () => request().user()).middleware('auth:token')\n";
+/**
+ * Adds `api: 'routes/api.ts'` to withRouting() in bootstrap/app.ts: uncomments a commented `// api:` entry,
+ * else inserts it after the `web:` entry, else at the start of withRouting({, else adds a withRouting() call
+ * before create(). Returns the source unchanged when api is already there, and undefined when it can't tell where.
+ * (Function replacers, so a `$` in the file is never read as a replacement pattern.)
+ */
+declare function addApiRouting(source: string): string | undefined;
+interface HttpCommandOptions {
+    /** Replaces serve() (tests). */
+    serve?: (app: Application, options: ServeOptions) => Promise<RunningServer>;
+    /** The terminal width for route:list. Default: process.stdout.columns, else 120. */
+    terminalWidth?: () => number;
+}
+/** Registers `serve`, `route:list` and `install:api` as closure commands (PC1). */
+declare function registerHttpCommands(kernel: ConsoleKernel, app: Application, options?: HttpCommandOptions): void;
+
+/**
+ * Binds the HTTP kernel (replacing any kernel bound before, such as Foundation's ClosureKernel), the exception
+ * handler, the response factory and the redirector, and merges the `http` config defaults.
+ *
+ * The HttpRequest is deliberately NOT bound on the application: the kernel creates one per request and puts it in
+ * the request scope with scope.instance(). A root `scoped()` binding would make bound(HttpRequest) true everywhere,
+ * and that check is how the URL generator, the redirects and the helpers know they are inside a request.
+ */
+declare class HttpServiceProvider extends ServiceProvider {
+    register(): void;
+    boot(): void;
+}
+
+export { API_ROUTES_STUB, ConvertEmptyStringsToNull, type ErrorClass, ErrorHandler, ExceptionsConfiguration, FormUploadedFile, type HttpCommandOptions, HttpException, HttpRedirectResponse, HttpRedirector, HttpResponseException, HttpResponseFactory, HttpServerError, HttpServiceProvider, IncomingRequest, type IncomingRequestOptions, Kernel, MiddlewareConfiguration, type RenderCallback, type ReportCallback, type ResolvedServeOptions, type RouteListFilters, type RouteListRow, type RunningServer, type Runtime, type ServeOptions, type StackFrame, TrimStrings, abort, abortIf, abortUnless, addApiRouting, applyExceptionCallbacks, applyMiddlewareCallbacks, back, bunRuntime, clientAddress, contentDisposition, currentRequest, debugPage, detectRuntime, escapeHtml, extensionFromMime, filterRouteList, formatRouteList, fromEntries, ipMatches, isBlank, mergeRecursive, mimeFromExtension, minimalPage, normalizeLists, optionalCookieJar, optionalSession, parseBracketKey, readBody, redirect, registerHttpCommands, request, requestScope, response, route, routeListRows, sanitize, serve, serveBun, serveNode, setClientAddress, stackFrames, statusFor, statusText, summarizeValidation, toWebRequest, transformLeaves, url, writeResponse };