@h3ravel/http 11.4.3 → 11.5.0

package/dist/index.d.ts

@@ -1,10 +1,460 @@
 /// <reference path="./app.globals.d.ts" />
 import { Command } from "@h3ravel/musket";
 import { DotNestedKeys, DotNestedValue, HttpContext, HttpContext as HttpContext$1, IMiddleware, IRequest, IResponse } from "@h3ravel/shared";
-import { EventHandlerRequest, H3Event } from "h3";
-import { ResponseHeaderMap, TypedHeaders } from "fetchdts";
+import { EventHandlerRequest, H3Event, HTTPResponse } from "h3";
 import { Application } from "@h3ravel/core";
+import { Url } from "@h3ravel/url";
 
+//#region src/Contracts/HttpContract.d.ts
+type RequestMethod = 'HEAD' | 'GET' | 'PUT' | 'DELETE' | 'TRACE' | 'OPTIONS' | 'PURGE' | 'POST' | 'CONNECT' | 'PATCH';
+type RequestObject = Record<string, any>;
+//#endregion
+//#region src/Bags/ParamBag.d.ts
+/**
+ * ParamBag is a container for key/value pairs
+ * for Node/H3 environments.
+ */
+declare class ParamBag implements Iterable<[string, any]> {
+  protected parameters: RequestObject;
+  /**
+   * The current H3 H3Event instance
+   */
+  readonly event: H3Event;
+  constructor(parameters: RequestObject | undefined,
+  /**
+   * The current H3 H3Event instance
+   */
+  event: H3Event);
+  /**
+   * Returns the parameters.
+   * @
+   * @param key The name of the parameter to return or null to get them all
+   *
+   * @throws BadRequestException if the value is not an array
+   */
+  all(key?: string): any;
+  get(key: string, defaultValue?: any): any;
+  set(key: string, value: any): void;
+  /**
+   * Returns true if the parameter is defined.
+   *
+   * @param key
+   */
+  has(key: string): boolean;
+  /**
+   * Removes a parameter.
+   *
+   * @param key
+   */
+  remove(key: string): void;
+  /**
+   *
+   * Returns the parameter as string.
+   *
+   * @param key
+   * @param defaultValue
+   * @throws UnexpectedValueException if the value cannot be converted to string
+   * @returns
+   */
+  getString(key: string, defaultValue?: string): string;
+  /**
+   * Returns the parameter value converted to integer.
+   *
+   * @param key
+   * @param defaultValue
+   * @throws UnexpectedValueException if the value cannot be converted to integer
+   */
+  getInt(key: string, defaultValue?: number): number;
+  /**
+   * Returns the parameter value converted to boolean.
+   *
+   * @param key
+   * @param defaultValue
+   * @throws UnexpectedValueException if the value cannot be converted to a boolean
+   */
+  getBoolean(key: string, defaultValue?: boolean): boolean;
+  /**
+   * Returns the alphabetic characters of the parameter value.
+   *
+   * @param key
+   * @param defaultValue
+   * @throws UnexpectedValueException if the value cannot be converted to string
+   */
+  getAlpha(key: string, defaultValue?: string): string;
+  /**
+   * Returns the alphabetic characters and digits of the parameter value.
+   *
+   * @param key
+   * @param defaultValue
+   * @throws UnexpectedValueException if the value cannot be converted to string
+   */
+  getAlnum(key: string, defaultValue?: string): string;
+  /**
+   * Returns the digits of the parameter value.
+   *
+   * @param key
+   * @param defaultValue
+   * @throws UnexpectedValueException if the value cannot be converted to string
+   * @returns
+   **/
+  getDigits(key: string, defaultValue?: string): string;
+  /**
+   * Returns the parameter keys.
+   */
+  keys(): string[];
+  /**
+   * Replaces the current parameters by a new set.
+   */
+  replace(parameters?: RequestObject): void;
+  /**
+   * Adds parameters.
+   */
+  add(parameters?: RequestObject): void;
+  /**
+   * Returns the number of parameters.
+   */
+  count(): number;
+  /**
+   * Returns an iterator for parameters.
+   *
+   * @returns
+   */
+  [Symbol.iterator](): ArrayIterator<[string, any]>;
+}
+//#endregion
+//#region src/UploadedFile.d.ts
+declare class UploadedFile {
+  originalName: string;
+  mimeType: string;
+  size: number;
+  content: File;
+  constructor(originalName: string, mimeType: string, size: number, content: File);
+  static createFromBase(file: File): UploadedFile;
+  /**
+   * Save to disk (Node environment only)
+   */
+  moveTo(destination: string): Promise<void>;
+}
+//#endregion
+//#region src/Bags/FileBag.d.ts
+type FileInput = UploadedFile | File | null | undefined;
+/**
+ * FileBag is a container for uploaded files
+ * for Node/H3 environments.
+ */
+declare class FileBag extends ParamBag {
+  protected parameters: Record<string, UploadedFile | UploadedFile[] | null>;
+  constructor(parameters: Record<string, FileInput | FileInput[]> | undefined,
+  /**
+   * The current H3 H3Event instance
+   */
+  event: H3Event);
+  /**
+   * Replace all stored files.
+   */
+  replace(files?: Record<string, FileInput | FileInput[]>): void;
+  /**
+   * Set a file or array of files.
+   */
+  set(key: string, value: FileInput | FileInput[]): void;
+  /**
+   * Add multiple files.
+   */
+  add(files?: Record<string, FileInput | FileInput[]>): void;
+  /**
+   * Get all stored files.
+   */
+  all(): Record<string, UploadedFile | UploadedFile[] | null>;
+  /**
+   * Normalize file input into UploadedFile instances.
+   */
+  protected convertFileInformation(file: FileInput): UploadedFile | null;
+}
+//#endregion
+//#region src/Bags/HeaderBag.d.ts
+/**
+ * HeaderBag — A container for HTTP headers
+ * for Node/H3 environments.
+ */
+declare class HeaderBag implements Iterable<[string, (string | null)[]]> {
+  protected static readonly UPPER = "_ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+  protected static readonly LOWER = "-abcdefghijklmnopqrstuvwxyz";
+  protected headers: Record<string, (string | null)[]>;
+  protected cacheControl: Record<string, string | boolean>;
+  constructor(headers?: Record<string, string | string[] | null>);
+  /**
+   * Returns all headers as string (for debugging / toString)
+   *
+   * @returns
+   */
+  toString(): string;
+  /**
+   * Returns all headers or specific header list
+   *
+   * @param key
+   * @returns
+   */
+  all(key?: string): Record<string, (string | null)[]> | (string | null)[];
+  /**
+   * Returns header keys
+   *
+   * @returns
+   */
+  keys(): string[];
+  /**
+   * Replace all headers with new set
+   *
+   * @param headers
+   */
+  replace(headers?: Record<string, string | string[] | null>): void;
+  /**
+   * Add multiple headers
+   *
+   * @param headers
+   */
+  add(headers: Record<string, string | string[] | null>): void;
+  /**
+   * Returns first header value by name or default
+   *
+   * @param key
+   * @param defaultValue
+   * @returns
+   */
+  get<R = undefined>(key: string, defaultValue?: string | null): R extends undefined ? string | null : R;
+  /**
+   * Sets a header by name.
+   *
+   * @param replace Whether to replace existing values (default true)
+   */
+  set(key: string, values: string | string[] | null, replace?: boolean): void;
+  /**
+   * Returns true if header exists
+   *
+   * @param key
+   * @returns
+   */
+  has(key: string): boolean;
+  /**
+   * Returns true if header contains value
+   *
+   * @param key
+   * @param value
+   * @returns
+   */
+  contains(key: string, value: string): boolean;
+  /**
+   * Removes a header
+   *
+   * @param key
+   */
+  remove(key: string): void;
+  /**
+   * Returns parsed date from header
+   *
+   * @param key
+   * @param defaultValue
+   * @returns
+   */
+  getDate(key: string, defaultValue?: Date | null): Date | null;
+  /**
+   * Adds a Cache-Control directive
+   *
+   * @param key
+   * @param value
+   */
+  addCacheControlDirective(key: string, value?: string | boolean): void;
+  /**
+   * Returns true if Cache-Control directive is defined
+   *
+   * @param key
+   * @returns
+   */
+  hasCacheControlDirective(key: string): boolean;
+  /**
+   * Returns a Cache-Control directive value by name
+   *
+   * @param key
+   * @returns
+   */
+  getCacheControlDirective(key: string): string | boolean | null;
+  /**
+   * Removes a Cache-Control directive
+   *
+   * @param key
+   * @returns
+   */
+  removeCacheControlDirective(key: string): void;
+  /**
+   * Number of headers
+   *
+   * @param key
+   * @returns
+   */
+  count(): number;
+  /**
+   * Normalize header name to lowercase with hyphens
+   *
+   * @param key
+   * @returns
+   */
+  protected normalizeKey(key: string): string;
+  /**
+   * Generates Cache-Control header string
+   *
+   * @param header
+   * @returns
+   */
+  protected getCacheControlHeader(): string;
+  /**
+   * Parses Cache-Control header
+   *
+   * @param header
+   * @returns
+   */
+  protected parseCacheControl(header: string): Record<string, string | boolean>;
+  /**
+   * Iterator support
+   * @returns
+   */
+  [Symbol.iterator](): Iterator<[string, (string | null)[]]>;
+}
+//#endregion
+//#region src/Bags/InputBag.d.ts
+/**
+ * InputBag is a container for user input values
+ * (e.g., query params, body, cookies)
+ * for Node/H3 environments.
+ */
+declare class InputBag extends ParamBag {
+  constructor(inputs: RequestObject | undefined,
+  /**
+   * The current H3 H3Event instance
+   */
+  event: H3Event);
+  /**
+   * Returns a scalar input value by name.
+   *
+   * @param key
+   * @param defaultValue
+   * @throws BadRequestException if the input contains a non-scalar value
+   * @returns
+   */
+  get<T extends string | number | boolean | null>(key: string, defaultValue?: T | null): T | string | number | boolean | null;
+  /**
+   * Replaces all current input values.
+   *
+   * @param inputs
+   * @returns
+   */
+  replace(inputs?: RequestObject): void;
+  /**
+   * Adds multiple input values.
+   *
+   * @param inputs
+   * @returns
+   */
+  add(inputs?: RequestObject): void;
+  /**
+   * Sets an input by name.
+   *
+   * @param key
+   * @param value
+   * @throws TypeError if value is not scalar or array
+   * @returns
+   */
+  set(key: string, value: any): void;
+  /**
+   * Returns true if a key exists.
+   *
+   * @param key
+   * @returns
+   */
+  has(key: string): boolean;
+  /**
+   * Returns all parameters.
+   *
+   * @returns
+   */
+  all(): RequestObject;
+  /**
+   * Converts a parameter value to string.
+   *
+   * @param key
+   * @param defaultValue
+   * @throws BadRequestException if input contains a non-scalar value
+   * @returns
+   */
+  getString(key: string, defaultValue?: string): string;
+  /**
+   * Filters input value with a predicate.
+   * Mimics PHP’s filter_var() in spirit, but simpler.
+   *
+   * @param key
+   * @param defaultValue
+   * @param filterFn
+   * @throws BadRequestException if validation fails
+   * @returns
+   */
+  filter<T = any>(key: string, defaultValue?: T | null, filterFn?: (value: any) => boolean): T | null;
+  /**
+   * Returns an enum value by key.
+   *
+   * @param key
+   * @param EnumClass
+   * @param defaultValue
+   * @throws BadRequestException if conversion fails
+   * @returns
+   */
+  getEnum<T extends Record<string, string | number>>(key: string, EnumClass: T, defaultValue?: T[keyof T] | null): T[keyof T] | null;
+  /**
+   * Removes a key.
+   *
+   * @param key
+   */
+  remove(key: string): void;
+  /**
+   * Returns all keys.
+   *
+   * @returns
+   */
+  keys(): string[];
+  /**
+   * Returns number of parameters.
+   *
+   * @returns
+   */
+  count(): number;
+}
+//#endregion
+//#region src/Bags/ServerBag.d.ts
+/**
+ * ServerBag — a simplified version of Symfony's ServerBag
+ * for Node/H3 environments.
+ *
+ * Responsible for extracting and normalizing HTTP headers
+ * from the incoming request.
+ */
+declare class ServerBag extends ParamBag {
+  constructor(parameters: Record<string, string | undefined> | undefined,
+  /**
+   * The current H3 H3Event instance
+   */
+  event: H3Event);
+  /**
+   * Returns all request headers, normalized to uppercase with underscores.
+   * Example: content-type → CONTENT_TYPE
+   */
+  getHeaders(): Record<string, string>;
+  /**
+   * Returns a specific header by name, case-insensitive.
+   */
+  get(name: string): string | undefined;
+  /**
+   * Returns true if a header exists.
+   */
+  has(name: string): boolean;
+}
+//#endregion
 //#region src/Commands/FireCommand.d.ts
 declare class FireCommand extends Command {
   /**
@@ -23,6 +473,48 @@ declare class FireCommand extends Command {
   protected fire(): Promise<void>;
 }
 //#endregion
+//#region src/Exceptions/BadRequestException.d.ts
+declare class BadRequestException extends Error {
+  constructor(message: string);
+}
+//#endregion
+//#region src/Exceptions/SuspiciousOperationException.d.ts
+declare class SuspiciousOperationException extends Error {
+  constructor(message: string);
+}
+//#endregion
+//#region src/Exceptions/UnexpectedValueException.d.ts
+declare class UnexpectedValueException extends Error {
+  constructor(message: string);
+}
+//#endregion
+//#region src/FormRequest.d.ts
+declare class FormRequest {
+  protected dataset: {
+    files: Record<string, File | UploadedFile | (File | UploadedFile)[]>;
+    input: Record<string, any>;
+  };
+  constructor(data: FormData);
+  /**
+   * Initialize the data
+   * @param data
+   */
+  initialize(data: FormData): void;
+  /**
+   * Get all uploaded files
+   */
+  files(): Record<string, File | UploadedFile | (File | UploadedFile)[]>;
+  /**
+   * Get all input fields
+   */
+  input(): Record<string, any>;
+  /**
+   * Get combined input and files
+   * File entries take precedence if names overlap.
+   */
+  all(): Record<string, any>;
+}
+//#endregion
 //#region src/Middleware.d.ts
 declare abstract class Middleware implements IMiddleware {
   abstract handle(context: HttpContext, next: () => Promise<unknown>): Promise<unknown>;
@@ -56,42 +548,355 @@ declare class HttpServiceProvider {
 //#endregion
 //#region src/Request.d.ts
 declare class Request implements IRequest {
+  #private;
+  /**
+   * The current H3 H3Event instance
+   */
+  private readonly event;
   /**
    * The current app instance
    */
   app: Application;
+  /**
+   * Parsed request body
+   */
+  body: unknown;
   /**
    * Gets route parameters.
    * @returns An object containing route parameters.
    */
-  readonly params: NonNullable<H3Event['context']['params']>;
+  params: NonNullable<H3Event['context']['params']>;
   /**
-   * Gets query parameters.
-   * @returns An object containing query parameters.
+   * All of the converted files for the request.
    */
-  readonly query: Record<string, string>;
+  protected convertedFiles?: Record<string, UploadedFile | UploadedFile[]>;
+  /**
+   * Form data from incoming request.
+   * @returns The FormRequest object.
+   */
+  protected formData: FormRequest;
+  /**
+   * Request body parameters (POST).
+   *
+   * @see getPayload() for portability between content types
+   */
+  protected request: InputBag;
+  /**
+   * Query string parameters (GET).
+   */
+  query: InputBag;
+  /**
+   * Uploaded files (FILES).
+   */
+  files: FileBag;
+  /**
+   * Server and execution environment parameters
+   */
+  server: ServerBag;
+  /**
+   * Cookies
+   */
+  cookies: InputBag;
+  /**
+   * The request attributes (parameters parsed from the PATH_INFO, ...).
+   */
+  attributes: ParamBag;
   /**
    * Gets the request headers.
    * @returns An object containing request headers.
    */
-  readonly headers: TypedHeaders<Record<keyof ResponseHeaderMap, string>>;
+  headers: HeaderBag;
+  protected content?: ReadableStream | string | false | null;
+  protected static formats?: Record<string, string[]> | undefined | null;
+  protected static httpMethodParameterOverride: boolean;
+  /**
+   * List of Acceptable Content Types
+   */
+  private acceptableContentTypes;
+  constructor(
   /**
    * The current H3 H3Event instance
    */
-  private readonly event;
-  constructor(event: H3Event,
+  event: H3Event,
   /**
    * The current app instance
    */
   app: Application);
   /**
-   * Get all input data (query + body).
+   * Factory method to create a Request instance from an H3Event.
+   */
+  static create(
+  /**
+   * The current H3 H3Event instance
+   */
+  event: H3Event,
+  /**
+   * The current app instance
+   */
+  app: Application): Promise<Request>;
+  /**
+   * Sets the parameters for this request.
+   *
+   * This method also re-initializes all properties.
+   *
+   * @param attributes
+   * @param cookies    The COOKIE parameters
+   * @param files      The FILES parameters
+   * @param server     The SERVER parameters
+   * @param content    The raw body data
+   */
+  initialize(): Promise<void>;
+  private setBody;
+  /**
+   * Retrieve all data from the instance (query + body).
+   */
+  all<T = Record<string, any>>(keys?: string | string[]): T;
+  /**
+   * Retrieve an input item from the request.
+   *
+   * @param key
+   * @param defaultValue
+   * @returns
+   */
+  input<K extends string | undefined>(key?: K, defaultValue?: any): K extends undefined ? RequestObject : any;
+  /**
+   * Retrieve a file from the request.
+   *
+   * @param key
+   * @param defaultValue
+   * @returns
+   */
+  file<K extends string | undefined = undefined>(key?: K, defaultValue?: any): K extends undefined ? Record<string, UploadedFile | UploadedFile[]> : UploadedFile | UploadedFile[];
+  /**
+   * Get an array of all of the files on the request.
+   */
+  allFiles(): Record<string, UploadedFile | UploadedFile[]>;
+  /**
+     * Extract and convert uploaded files from FormData.
+     */
+  convertUploadedFiles(files: Record<string, UploadedFile | UploadedFile[]>): Record<string, UploadedFile | UploadedFile[]>;
+  /**
+   * Determine if the data contains a given key.
+   *
+   * @param keys
+   * @returns
+   */
+  has(keys: string[] | string): boolean;
+  /**
+   * Determine if the instance is missing a given key.
+   */
+  missing(key: string | string[]): boolean;
+  /**
+   * Get a subset containing the provided keys with values from the instance data.
+   *
+   * @param keys
+   * @returns
+   */
+  only<T = Record<string, any>>(keys: string[]): T;
+  /**
+   * Get all of the data except for a specified array of items.
+   *
+   * @param keys
+   * @returns
+   */
+  except<T = Record<string, any>>(keys: string[]): T;
+  /**
+   * Merges new input data into the current request's input source.
+   *
+   * @param input - An object containing key-value pairs to merge.
+   * @returns this - For fluent chaining.
+   */
+  merge(input: Record<string, any>): this;
+  /**
+   * Merge new input into the request's input, but only when that key is missing from the request.
+   *
+   * @param input
+   */
+  mergeIfMissing(input: Record<string, any>): this;
+  /**
+   * Get the keys for all of the input and files.
+   */
+  keys(): string[];
+  /**
+   * Determine if the request is sending JSON.
+   *
+   * @return bool
+   */
+  isJson(): boolean;
+  /**
+   * Determine if the current request probably expects a JSON response.
+   *
+   * @returns
+   */
+  expectsJson(): boolean;
+  /**
+   * Determine if the current request is asking for JSON.
+   *
+   * @returns
+   */
+  wantsJson(): boolean;
+  /**
+   * Gets a list of content types acceptable by the client browser in preferable order.
+   * @returns {string[]}
+   */
+  getAcceptableContentTypes(): string[];
+  /**
+   * Determine if the request is the result of a PJAX call.
+   *
+   * @return bool
+   */
+  pjax(): boolean;
+  /**
+   * Returns true if the request is an XMLHttpRequest (AJAX).
+   *
+   * @alias isXmlHttpRequest()
+   * @returns {boolean}
+   */
+  ajax(): boolean;
+  /**
+   * Returns true if the request is an XMLHttpRequest (AJAX).
+   */
+  isXmlHttpRequest(): boolean;
+  /**
+   * Returns the value of the requested header.
+   */
+  getHeader(name: string): string | undefined | null;
+  /**
+   * Checks if the request method is of specified type.
+   *
+   * @param method Uppercase request method (GET, POST etc)
+   */
+  isMethod(method: string): boolean;
+  /**
+   * Checks whether or not the method is safe.
+   *
+   * @see https://tools.ietf.org/html/rfc7231#section-4.2.1
+   */
+  isMethodSafe(): boolean;
+  /**
+   * Checks whether or not the method is idempotent.
+   */
+  isMethodIdempotent(): boolean;
+  /**
+   * Checks whether the method is cacheable or not.
+   *
+   * @see https://tools.ietf.org/html/rfc7231#section-4.2.3
    */
-  all<T = Record<string, unknown>>(): Promise<T>;
+  isMethodCacheable(): boolean;
   /**
-   * Get a single input field from query or body.
+   * Initializes HTTP request formats.
+   */
+  protected static initializeFormats(): void;
+  /**
+   * Gets the request "intended" method.
+   *
+   * If the X-HTTP-Method-Override header is set, and if the method is a POST,
+   * then it is used to determine the "real" intended HTTP method.
+   *
+   * The _method request parameter can also be used to determine the HTTP method,
+   * but only if enableHttpMethodParameterOverride() has been called.
+   *
+   * The method is always an uppercased string.
+   *
+   * @see getRealMethod()
+   */
+  getMethod(): RequestMethod;
+  /**
+   * Gets the "real" request method.
+   *
+   * @see getMethod()
+   */
+  getRealMethod(): RequestMethod;
+  /**
+   * Get the client IP address.
+   */
+  ip(): string | undefined;
+  /**
+   * Get a URI instance for the request.
+   */
+  uri(): Url;
+  /**
+   * Get the full URL for the request.
+   */
+  fullUrl(): string;
+  /**
+   * Return the Request instance.
+   */
+  instance(): this;
+  /**
+   * Get the request method.
+   */
+  method(): RequestMethod;
+  /**
+   * Get the JSON payload for the request.
+   *
+   * @param  key
+   * @param  defaultValue
+   * @return {InputBag}
+   */
+  json<K extends string | undefined = undefined>(key?: string, defaultValue?: any): K extends undefined ? InputBag : any;
+  /**
+   * Get the input source for the request.
+   *
+   * @return {InputBag}
+   */
+  protected getInputSource(): InputBag;
+  /**
+   * Returns the request body content.
+   *
+   * @param asStream If true, returns a ReadableStream instead of the parsed string
+   * @return {string | ReadableStream | Promise<string | ReadableStream>}
+   */
+  getContent(asStream?: boolean): string | ReadableStream;
+  /**
+   * Determine if the uploaded data contains a file.
+   *
+   * @param  key
+   * @return boolean
+   */
+  hasFile(key: string): boolean;
+  /**
+   * Check that the given file is a valid file instance.
+   *
+   * @param file
+   * @return boolean
+   */
+  protected isValidFile(file: UploadedFile): boolean;
+  /**
+   * Gets a "parameter" value from any bag.
+   *
+   * This method is mainly useful for libraries that want to provide some flexibility. If you don't need the
+   * flexibility in controllers, it is better to explicitly get request parameters from the appropriate
+   * public property instead (attributes, query, request).
+   *
+   * Order of precedence: PATH (routing placeholders or custom attributes), GET, POST
+   *
+   * @internal use explicit input sources instead
+   */
+  get(key: string, defaultValue?: any): any;
+  /**
+   * Enables support for the _method request parameter to determine the intended HTTP method.
+   *
+   * Be warned that enabling this feature might lead to CSRF issues in your code.
+   * Check that you are using CSRF tokens when required.
+   * If the HTTP method parameter override is enabled, an html-form with method "POST" can be altered
+   * and used to send a "PUT" or "DELETE" request via the _method request parameter.
+   * If these methods are not protected against CSRF, this presents a possible vulnerability.
+   *
+   * The HTTP method can only be overridden when the real HTTP method is POST.
+   */
+  static enableHttpMethodParameterOverride(): void;
+  /**
+   * Checks whether support for the _method request parameter is enabled.
+   */
+  static getHttpMethodParameterOverride(): boolean;
+  /**
+   * Dump the items.
+   *
+   * @param  keys
+   * @return this
    */
-  input<T = unknown>(key: string, defaultValue?: T): Promise<T>;
+  dump(...keys: any[]): this;
   /**
    * Get the base event
    */
@@ -118,7 +923,7 @@ type BodyResource = Resource & {
 /**
  * Class to render API resource
  */
-declare class JsonResource<R extends Resource = any> {
+declare class JsonResource<R$1 extends Resource = any> {
   #private;
   protected event: H3Event;
   /**
@@ -132,7 +937,7 @@ declare class JsonResource<R extends Resource = any> {
   /**
    * The data to send to the client
    */
-  resource: R;
+  resource: R$1;
   /**
    * The final response data object
    */
@@ -154,7 +959,7 @@ declare class JsonResource<R extends Resource = any> {
    * @param res The response instance
    * @param rsc The data to send to the client
    */
-  constructor(event: H3Event, rsc: R);
+  constructor(event: H3Event, rsc: R$1);
   /**
    * Return the data in the expected format
    *
@@ -219,7 +1024,7 @@ declare class Response implements IResponse {
    * Set a header.
    */
   setHeader(name: string, value: string): this;
-  html(content: string): string;
+  html(content: string): HTTPResponse;
   /**
    * Send a JSON response.
    */
@@ -231,7 +1036,7 @@ declare class Response implements IResponse {
   /**
    * Redirect to another URL.
    */
-  redirect(url: string, status?: number): string;
+  redirect(location: string, status?: number, statusText?: string | undefined): HTTPResponse;
   /**
    * Apply headers before sending response.
    */
@@ -243,4 +1048,4 @@ declare class Response implements IResponse {
   getEvent<K extends DotNestedKeys<H3Event>>(key: K): DotNestedValue<H3Event, K>;
 }
 //#endregion
-export { ApiResource, FireCommand, HttpContext, HttpServiceProvider, JsonResource, LogRequests, Middleware, Request, Resource, Response };
+export { ApiResource, BadRequestException, FileBag, FireCommand, FormRequest, HeaderBag, HttpContext, HttpServiceProvider, InputBag, JsonResource, LogRequests, Middleware, ParamBag, Request, RequestMethod, RequestObject, Resource, Response, ServerBag, SuspiciousOperationException, UnexpectedValueException, UploadedFile };