@visulima/storage 1.0.9 → 1.0.10

package/dist/handler/http/node/index.d.ts

@@ -1,85 +1,76 @@
 import { IncomingMessage, ServerResponse } from 'node:http';
-import { U as UploadFile, m as UploadResponse } from "../../../packem_shared/storage.d-CEM1upWM.js";
+import { U as UploadFile, m as UploadResponse } from "../../../packem_shared/storage.d-DIav_lF1.js";
 import { Readable } from 'node:stream';
-import { H as Handlers, A as AsyncHandler, U as UploadOptions, R as ResponseFile, a as ResponseList, M as MethodHandler } from "../../../packem_shared/types.d-CggTCgXr.js";
-export type { B as BaseHandler, b as RequestEvent, c as UploadErrorEvent, d as UploadEvent } from "../../../packem_shared/types.d-CggTCgXr.js";
-import { B as BaseHandlerCore } from "../../../packem_shared/tus-base.d-DLzKE54M.js";
-export { T as TUS_RESUMABLE, a as TUS_VERSION } from "../../../packem_shared/tus-base.d-DLzKE54M.js";
+import { H as Handlers, A as AsyncHandler, U as UploadOptions, R as ResponseFile, a as ResponseList, M as MethodHandler } from "../../../packem_shared/types.d-jAs_Rp_v.js";
+export type { B as BaseHandler, b as RequestEvent, c as UploadErrorEvent, d as UploadEvent } from "../../../packem_shared/types.d-jAs_Rp_v.js";
+import { B as BaseHandlerCore } from "../../../packem_shared/tus-base.d-BiEg5t4t.js";
+export { T as TUS_RESUMABLE, a as TUS_VERSION } from "../../../packem_shared/tus-base.d-BiEg5t4t.js";
 import 'node:crypto';
 import 'lru-cache';
 import 'node:events';
 import '@visulima/pagination';
-import "../../../packem_shared/media-transformer.d-Quf4ai47.js";
-import "../../../packem_shared/types.d-CrUWY4On.js";
+import "../../../packem_shared/media-transformer.d-CvMFjINm.js";
+import "../../../packem_shared/types.d-CAAzKiI6.js";
 /**
-* Base handler for Node.js platform (IncomingMessage/ServerResponse).
-* Extends BaseHandlerCore with Node.js-specific request/response handling.
-* @template TFile The file type used by this handler.
-* @template NodeRequest The Node.js request type.
-* @template NodeResponse The Node.js response type.
-*/
+ * Base handler for Node.js platform (IncomingMessage/ServerResponse).
+ * Extends BaseHandlerCore with Node.js-specific request/response handling.
+ * @template TFile The file type used by this handler.
+ * @template NodeRequest The Node.js request type.
+ * @template NodeResponse The Node.js response type.
+ */
 declare abstract class BaseHandlerNode<TFile extends UploadFile, NodeRequest extends IncomingMessage = IncomingMessage, NodeResponse extends ServerResponse = ServerResponse> extends BaseHandlerCore<TFile> implements MethodHandler<NodeRequest, NodeResponse> {
   /**
-  * Limiting enabled HTTP method handler.
-  */
+   * Limiting enabled HTTP method handler.
+   */
   static readonly methods: Handlers[];
   /**
-  * Map of registered HTTP method handlers.
-  */
+   * Map of registered HTTP method handlers.
+   */
   protected registeredHandlers: Map<string, AsyncHandler<NodeRequest, NodeResponse>>;
   constructor(options: UploadOptions<TFile>);
   /**
-  * Gets the registered handlers map.
-  * @returns Map of registered handlers.
-  */
+   * Gets the registered handlers map.
+   * @returns Map of registered handlers.
+   */
   get handlers(): Map<string, AsyncHandler<NodeRequest, NodeResponse>>;
   /**
-  * Handles HTTP request (alias for upload method).
-  * @param request Node.js IncomingMessage.
-  * @param response Node.js ServerResponse.
-  */
+   * Handles HTTP request (alias for upload method).
+   * @param request Node.js IncomingMessage.
+   * @param response Node.js ServerResponse.
+   */
   handle: (request: NodeRequest, response: NodeResponse) => Promise<void>;
   /**
-  * Main upload handler that processes HTTP requests and routes them to appropriate method handlers.
-  * @param request Node.js IncomingMessage.
-  * @param response Node.js ServerResponse.
-  * @param next Optional Express-style next function for middleware compatibility.
-  * @throws {UploadError} When storage is not ready or method is not allowed.
-  */
+   * Main upload handler that processes HTTP requests and routes them to appropriate method handlers.
+   * @param request Node.js IncomingMessage.
+   * @param response Node.js ServerResponse.
+   * @param next Optional Express-style next function for middleware compatibility.
+   * @throws {UploadError} When storage is not ready or method is not allowed.
+   */
   upload: (request: NodeRequest, response: NodeResponse, next?: () => void) => Promise<void>;
   /**
-  * Compose and register HTTP method handlers.
-  * Subclasses should override this to register their specific handlers.
-  */
+   * Compose and register HTTP method handlers.
+   * Subclasses should override this to register their specific handlers.
+   */
   protected abstract compose(): void;
   /**
-  * Sends an HTTP response with the provided body, headers, and status code.
-  * @param response Node.js ServerResponse to send data to.
-  * @param body Response body, headers, and status code.
-  */
-  send(response: NodeResponse, {
-    body,
-    headers,
-    statusCode
-  }: UploadResponse): void;
-  /**
-  * Sends an error response to the client with appropriate status code and message.
-  * @param response Node.js ServerResponse to send error to.
-  * @param error Error object to convert to HTTP error response.
-  */
+   * Sends an HTTP response with the provided body, headers, and status code.
+   * @param response Node.js ServerResponse to send data to.
+   * @param body Response body, headers, and status code.
+   */
+  send(response: NodeResponse, { body, headers, statusCode }: UploadResponse): void;
+  /**
+   * Sends an error response to the client with appropriate status code and message.
+   * @param response Node.js ServerResponse to send error to.
+   * @param error Error object to convert to HTTP error response.
+   */
   sendError(response: NodeResponse, error: Error): Promise<void>;
   /**
-  * Sends streaming response to client with proper backpressure handling and range request support.
-  * @param response Node.js ServerResponse to stream data to.
-  * @param stream Readable stream containing the file data.
-  * @param options Streaming options including headers, range, size, and status code.
-  */
-  sendStream(response: NodeResponse, stream: Readable, {
-    headers,
-    range,
-    size,
-    statusCode
-  }: {
+   * Sends streaming response to client with proper backpressure handling and range request support.
+   * @param response Node.js ServerResponse to stream data to.
+   * @param stream Readable stream containing the file data.
+   * @param options Streaming options including headers, range, size, and status code.
+   */
+  sendStream(response: NodeResponse, stream: Readable, { headers, range, size, statusCode }: {
     headers?: Record<string, string | number>;
     range?: {
       end: number;
@@ -89,280 +80,276 @@ declare abstract class BaseHandlerNode<TFile extends UploadFile, NodeRequest ext
     statusCode?: number;
   }): void;
   /**
-  * Finish upload by sending final response to client with completed file data.
-  * @param _request HTTP request (unused parameter)
-  * @param response HTTP response object to send final response to
-  * @param uploadResponse Final upload response data containing body, headers, and status code
-  */
+   * Finish upload by sending final response to client with completed file data.
+   * @param _request HTTP request (unused parameter)
+   * @param response HTTP response object to send final response to
+   * @param uploadResponse Final upload response data containing body, headers, and status code
+   */
   protected finish(_request: NodeRequest, response: NodeResponse, uploadResponse: UploadResponse | ResponseFile<TFile>): void;
   /**
-  * Build file URL from request and file data.
-  * @param request HTTP request with optional originalUrl property
-  * @param file File object containing ID and content type
-  * @returns Constructed file URL with extension based on content type
-  */
+   * Build file URL from request and file data.
+   * @param request HTTP request with optional originalUrl property
+   * @param file File object containing ID and content type
+   * @returns Constructed file URL with extension based on content type
+   */
   protected buildFileUrl(request: NodeRequest & {
     originalUrl?: string;
   }, file: TFile): string;
   /**
-  * Negotiates content type based on Accept header and supported formats.
-  * @param request HTTP request object containing Accept header.
-  * @param supportedTypes Array of supported MIME types to match against.
-  * @returns Best matching content type or undefined if no match found.
-  */
+   * Negotiates content type based on Accept header and supported formats.
+   * @param request HTTP request object containing Accept header.
+   * @param supportedTypes Array of supported MIME types to match against.
+   * @returns Best matching content type or undefined if no match found.
+   */
   negotiateContentType(request: NodeRequest, supportedTypes: string[]): string | undefined;
   /**
-  * Default OPTIONS handler.
-  * @param _request HTTP request (unused)
-  * @param _response HTTP response (unused)
-  * @returns Promise resolving to ResponseFile with CORS headers
-  */
+   * Default OPTIONS handler.
+   * @param _request HTTP request (unused)
+   * @param _response HTTP response (unused)
+   * @returns Promise resolving to ResponseFile with CORS headers
+   */
   options(_request: NodeRequest, _response: NodeResponse): Promise<ResponseFile<TFile>>;
   /**
-  * Retrieves a file or list of files based on the request path.
-  * @param request Node.js IncomingMessage with optional originalUrl.
-  * @param response Node.js ServerResponse.
-  * @returns Promise resolving to a single file, paginated list, or array of files.
-  * @throws {UploadError} When file is not found or storage error occurs.
-  */
+   * Retrieves a file or list of files based on the request path.
+   * @param request Node.js IncomingMessage with optional originalUrl.
+   * @param response Node.js ServerResponse.
+   * @returns Promise resolving to a single file, paginated list, or array of files.
+   * @throws {UploadError} When file is not found or storage error occurs.
+   */
   get(request: NodeRequest & {
     originalUrl?: string;
   }, _response: NodeResponse): Promise<ResponseFile<TFile> | ResponseList<TFile>>;
   /**
-  * Returns a list of uploaded files with optional pagination support.
-  * @param request Node.js IncomingMessage containing query parameters for pagination.
-  * @param _response Node.js ServerResponse (unused).
-  * @returns Promise resolving to a paginated or complete list of uploaded files.
-  */
+   * Returns a list of uploaded files with optional pagination support.
+   * @param request Node.js IncomingMessage containing query parameters for pagination.
+   * @param _response Node.js ServerResponse (unused).
+   * @returns Promise resolving to a paginated or complete list of uploaded files.
+   */
   list(request: NodeRequest, _response: NodeResponse): Promise<ResponseList<TFile>>;
   /**
-  * Streams download of a file with resumable support using HTTP range requests.
-  * @param request Node.js IncomingMessage with optional originalUrl and range header.
-  * @param response Node.js ServerResponse to stream the file to.
-  * @throws {HttpError} When file is not found or streaming is not supported.
-  */
+   * Streams download of a file with resumable support using HTTP range requests.
+   * @param request Node.js IncomingMessage with optional originalUrl and range header.
+   * @param response Node.js ServerResponse to stream the file to.
+   * @throws {HttpError} When file is not found or streaming is not supported.
+   */
   download(request: NodeRequest & {
     originalUrl?: string;
   }, response: NodeResponse): Promise<void>;
   /**
-  * Check if error is related to undefined ID or path and throw appropriate HTTP error.
-  * @param error Error object to check
-  */
+   * Check if error is related to undefined ID or path and throw appropriate HTTP error.
+   * @param error Error object to check
+   */
   protected override checkForUndefinedIdOrPath(error: unknown): void;
 }
 /**
-* Multipart/form-data upload handler (Node.js version).
-* @example
-* ```ts
-* const multipart = new Multipart({
-*   storage,
-*   maxFileSize: 100 * 1024 * 1024, // 100MB
-* });
-*
-* app.use('/files', multipart.handle);
-* ```
-*/
+ * Multipart/form-data upload handler (Node.js version).
+ * @example
+ * ```ts
+ * const multipart = new Multipart({
+ *   storage,
+ *   maxFileSize: 100 * 1024 * 1024, // 100MB
+ * });
+ *
+ * app.use('/files', multipart.handle);
+ * ```
+ */
 declare class Multipart<TFile extends UploadFile, NodeRequest extends IncomingMessage = IncomingMessage, NodeResponse extends ServerResponse = ServerResponse> extends BaseHandlerNode<TFile, NodeRequest, NodeResponse> {
   /**
-  * Limiting enabled http method handler
-  */
+   * Limiting enabled http method handler
+   */
   static override readonly methods: Handlers[];
   private readonly multipartBase;
   /**
-  * Maximum file size allowed for multipart uploads
-  */
+   * Maximum file size allowed for multipart uploads
+   */
   private maxFileSize;
   /**
-  * Maximum header size allowed for multipart parser
-  */
+   * Maximum header size allowed for multipart parser
+   */
   private maxHeaderSize;
   constructor(options: UploadOptions<TFile>);
   /**
-  * Handles multipart/form-data POST requests for file uploads.
-  * @param request Node.js IncomingMessage containing multipart data.
-  * @returns Promise resolving to ResponseFile with upload result.
-  */
+   * Handles multipart/form-data POST requests for file uploads.
+   * @param request Node.js IncomingMessage containing multipart data.
+   * @returns Promise resolving to ResponseFile with upload result.
+   */
   post(request: NodeRequest): Promise<ResponseFile<TFile>>;
   /**
-  * Delete an uploaded file.
-  * @param request Node.js IncomingMessage with file ID
-  * @returns Promise resolving to ResponseFile with deletion result
-  */
+   * Delete an uploaded file.
+   * @param request Node.js IncomingMessage with file ID
+   * @returns Promise resolving to ResponseFile with deletion result
+   */
   delete(request: NodeRequest): Promise<ResponseFile<TFile>>;
   /**
-  * Compose and register HTTP method handlers.
-  */
+   * Compose and register HTTP method handlers.
+   */
   protected compose(): void;
 }
 /**
-* REST API handler for direct binary file uploads (Node.js version).
-*
-* This handler provides a clean REST interface for file operations:
-* - POST: Create a new file with raw binary data or initialize chunked upload
-* - PUT: Create or update a file (requires ID in URL)
-* - PATCH: Upload chunks for chunked uploads (requires ID in URL)
-* - GET: Retrieve a file or list files
-* - DELETE: Delete a file (single) or multiple files (via ?ids=id1,id2 or JSON body)
-* - HEAD: Get file metadata and upload progress
-* - OPTIONS: CORS preflight
-* @example
-* ```ts
-* const rest = new Rest({
-*   storage,
-* });
-*
-* app.use('/files', rest.handle);
-* ```
-*/
+ * REST API handler for direct binary file uploads (Node.js version).
+ *
+ * This handler provides a clean REST interface for file operations:
+ * - POST: Create a new file with raw binary data or initialize chunked upload
+ * - PUT: Create or update a file (requires ID in URL)
+ * - PATCH: Upload chunks for chunked uploads (requires ID in URL)
+ * - GET: Retrieve a file or list files
+ * - DELETE: Delete a file (single) or multiple files (via ?ids=id1,id2 or JSON body)
+ * - HEAD: Get file metadata and upload progress
+ * - OPTIONS: CORS preflight
+ * @example
+ * ```ts
+ * const rest = new Rest({
+ *   storage,
+ * });
+ *
+ * app.use('/files', rest.handle);
+ * ```
+ */
 declare class Rest<TFile extends UploadFile, NodeRequest extends IncomingMessage = IncomingMessage, NodeResponse extends ServerResponse = ServerResponse> extends BaseHandlerNode<TFile, NodeRequest, NodeResponse> {
   /**
-  * Limiting enabled http method handler
-  */
+   * Limiting enabled http method handler
+   */
   static override readonly methods: Handlers[];
   private readonly restBase;
   constructor(options: UploadOptions<TFile>);
   /**
-  * Compose and register HTTP method handlers.
-  */
+   * Compose and register HTTP method handlers.
+   */
   protected override compose(): void;
   /**
-  * Build file URL from request and file data.
-  * @param requestUrl Request URL string
-  * @param file File object containing ID and content type
-  * @returns Constructed file URL with extension based on content type
-  */
+   * Build file URL from request and file data.
+   * @param requestUrl Request URL string
+   * @param file File object containing ID and content type
+   * @returns Constructed file URL with extension based on content type
+   */
   protected buildFileUrlForRest(requestUrl: string, file: TFile): string;
   /**
-  * Creates a new file via POST request with raw binary data.
-  * Supports both full file uploads and chunked upload initialization.
-  * @param request Node.js IncomingMessage with file data.
-  * @returns Promise resolving to ResponseFile with upload result.
-  */
+   * Creates a new file via POST request with raw binary data.
+   * Supports both full file uploads and chunked upload initialization.
+   * @param request Node.js IncomingMessage with file data.
+   * @returns Promise resolving to ResponseFile with upload result.
+   */
   post(request: NodeRequest): Promise<ResponseFile<TFile>>;
   /**
-  * Create or update a file via PUT request.
-  * Requires file ID in the URL path.
-  * @param request Node.js IncomingMessage with file ID and data
-  * @returns Promise resolving to ResponseFile with upload result
-  */
+   * Create or update a file via PUT request.
+   * Requires file ID in the URL path.
+   * @param request Node.js IncomingMessage with file ID and data
+   * @returns Promise resolving to ResponseFile with upload result
+   */
   put(request: NodeRequest): Promise<ResponseFile<TFile>>;
   /**
-  * Delete an uploaded file or multiple files.
-  * Supports single file (ID in URL) or batch delete (via ?ids=id1,id2 or JSON body).
-  * @param request Node.js IncomingMessage with file ID(s)
-  * @returns Promise resolving to ResponseFile (single) or ResponseList (batch) with deletion result
-  */
+   * Delete an uploaded file or multiple files.
+   * Supports single file (ID in URL) or batch delete (via ?ids=id1,id2 or JSON body).
+   * @param request Node.js IncomingMessage with file ID(s)
+   * @returns Promise resolving to ResponseFile (single) or ResponseList (batch) with deletion result
+   */
   delete(request: NodeRequest): Promise<ResponseFile<TFile> | ResponseList<TFile>>;
   /**
-  * Uploads a chunk via PATCH request for chunked uploads.
-  * Headers required: X-Chunk-Offset (byte offset), Content-Length (chunk size).
-  * Optional: X-Chunk-Checksum (SHA256 checksum for validation).
-  * @param request Node.js IncomingMessage with chunk data.
-  * @returns Promise resolving to ResponseFile with upload progress.
-  */
+   * Uploads a chunk via PATCH request for chunked uploads.
+   * Headers required: X-Chunk-Offset (byte offset), Content-Length (chunk size).
+   * Optional: X-Chunk-Checksum (SHA256 checksum for validation).
+   * @param request Node.js IncomingMessage with chunk data.
+   * @returns Promise resolving to ResponseFile with upload progress.
+   */
   patch(request: NodeRequest): Promise<ResponseFile<TFile>>;
   /**
-  * Get file metadata via HEAD request.
-  * For chunked uploads, also returns upload progress information.
-  * @param request Node.js IncomingMessage with file ID
-  * @returns Promise resolving to ResponseFile with metadata headers
-  */
+   * Get file metadata via HEAD request.
+   * For chunked uploads, also returns upload progress information.
+   * @param request Node.js IncomingMessage with file ID
+   * @returns Promise resolving to ResponseFile with metadata headers
+   */
   head(request: NodeRequest): Promise<ResponseFile<TFile>>;
   /**
-  * Handle OPTIONS requests with REST API capabilities.
-  * @returns Promise resolving to ResponseFile with CORS headers
-  */
+   * Handle OPTIONS requests with REST API capabilities.
+   * @returns Promise resolving to ResponseFile with CORS headers
+   */
   override options(): Promise<ResponseFile<TFile>>;
   /**
-  * Retrieves a file or list of files based on the request path.
-  * Delegates to BaseHandlerNode.get() method.
-  * @param request Node.js IncomingMessage with optional originalUrl.
-  * @param response Node.js ServerResponse.
-  * @returns Promise resolving to a single file, paginated list, or array of files.
-  */
+   * Retrieves a file or list of files based on the request path.
+   * Delegates to BaseHandlerNode.get() method.
+   * @param request Node.js IncomingMessage with optional originalUrl.
+   * @param response Node.js ServerResponse.
+   * @returns Promise resolving to a single file, paginated list, or array of files.
+   */
   override get(request: NodeRequest, response: NodeResponse): Promise<ResponseFile<TFile> | ResponseList<TFile>>;
 }
 /**
-* TUS resumable upload protocol handler (Node.js version).
-*
-* [tus resumable upload protocol](https://github.com/tus/tus-resumable-upload-protocol/blob/master/protocol.md)
-* @example
-* ```ts
-* const tus = new Tus({storage});
-*
-* app.all('/files', tus.handle);
-* ```
-*/
+ * TUS resumable upload protocol handler (Node.js version).
+ *
+ * [tus resumable upload protocol](https://github.com/tus/tus-resumable-upload-protocol/blob/master/protocol.md)
+ * @example
+ * ```ts
+ * const tus = new Tus({storage});
+ *
+ * app.all('/files', tus.handle);
+ * ```
+ */
 declare class Tus<TFile extends UploadFile, NodeRequest extends IncomingMessage = IncomingMessage, NodeResponse extends ServerResponse = ServerResponse> extends BaseHandlerNode<TFile, NodeRequest, NodeResponse> {
   /**
-  * Limiting enabled http method handler
-  */
+   * Limiting enabled http method handler
+   */
   static override readonly methods: Handlers[];
   override disableTerminationForFinishedUploads: boolean;
   private readonly tusBase;
   constructor(options: UploadOptions<TFile>);
   /**
-  * Handle OPTIONS requests with TUS protocol capabilities.
-  * @returns Promise resolving to ResponseFile with TUS headers
-  */
+   * Handle OPTIONS requests with TUS protocol capabilities.
+   * @returns Promise resolving to ResponseFile with TUS headers
+   */
   override options(): Promise<ResponseFile<TFile>>;
   /**
-  * Creates a new TUS upload and optionally starts uploading data.
-  * @param request Node.js IncomingMessage with TUS headers.
-  * @returns Promise resolving to ResponseFile with upload location and offset.
-  */
+   * Creates a new TUS upload and optionally starts uploading data.
+   * @param request Node.js IncomingMessage with TUS headers.
+   * @returns Promise resolving to ResponseFile with upload location and offset.
+   */
   post(request: NodeRequest): Promise<ResponseFile<TFile>>;
   /**
-  * Write a chunk of data to an existing TUS upload.
-  * @param request Node.js IncomingMessage with chunk data and TUS headers
-  * @returns Promise resolving to ResponseFile with updated offset
-  */
+   * Write a chunk of data to an existing TUS upload.
+   * @param request Node.js IncomingMessage with chunk data and TUS headers
+   * @returns Promise resolving to ResponseFile with updated offset
+   */
   patch(request: NodeRequest): Promise<ResponseFile<TFile>>;
   /**
-  * Get current upload offset and metadata for TUS resumable uploads.
-  * @param request Node.js IncomingMessage with upload ID
-  * @returns Promise resolving to ResponseFile with upload-offset and metadata headers
-  */
+   * Get current upload offset and metadata for TUS resumable uploads.
+   * @param request Node.js IncomingMessage with upload ID
+   * @returns Promise resolving to ResponseFile with upload-offset and metadata headers
+   */
   head(request: NodeRequest): Promise<ResponseFile<TFile>>;
   /**
-  * Get TUS upload metadata and current status.
-  * @param request Node.js IncomingMessage with upload ID
-  * @returns Promise resolving to ResponseFile with file metadata as JSON
-  */
+   * Get TUS upload metadata and current status.
+   * @param request Node.js IncomingMessage with upload ID
+   * @returns Promise resolving to ResponseFile with file metadata as JSON
+   */
   override get(request: NodeRequest): Promise<ResponseFile<TFile>>;
   /**
-  * Delete a TUS upload and its associated data.
-  * @param request Node.js IncomingMessage with upload ID
-  * @returns Promise resolving to ResponseFile with deletion confirmation
-  */
+   * Delete a TUS upload and its associated data.
+   * @param request Node.js IncomingMessage with upload ID
+   * @returns Promise resolving to ResponseFile with deletion confirmation
+   */
   delete(request: NodeRequest): Promise<ResponseFile<TFile>>;
   /**
-  * Send TUS protocol response with required headers.
-  * @param response Node.js ServerResponse to send response to
-  * @param uploadResponse Response data with body, headers, and status code
-  */
-  override send(response: NodeResponse, {
-    body,
-    headers,
-    statusCode
-  }: UploadResponse): void;
-  /**
-  * Compose and register HTTP method handlers.
-  */
+   * Send TUS protocol response with required headers.
+   * @param response Node.js ServerResponse to send response to
+   * @param uploadResponse Response data with body, headers, and status code
+   */
+  override send(response: NodeResponse, { body, headers, statusCode }: UploadResponse): void;
+  /**
+   * Compose and register HTTP method handlers.
+   */
   protected compose(): void;
   /**
-  * Build file URL for TUS uploads (without file extension).
-  *
-  * On the Node runtime the TUS protocol chain only carries the request *path* (`requestUrl` is
-  * `request.originalUrl || request.url`), so an absolute `Location` can only be produced when that
-  * path is itself an absolute URL (e.g. an upstream proxy rewrote it). When it is just a path the
-  * `Location` is necessarily relative — the request headers are not threaded through the protocol
-  * methods. Use the fetch/hono handlers (which receive `request.url` with the origin) or set
-  * `useRelativeLocation: true` explicitly for relative URLs everywhere.
-  * @param requestUrl Request URL string (path-only on Node unless rewritten to an absolute URL).
-  * @param file File object containing ID
-  * @returns Constructed file URL for TUS protocol
-  */
+   * Build file URL for TUS uploads (without file extension).
+   *
+   * On the Node runtime the TUS protocol chain only carries the request *path* (`requestUrl` is
+   * `request.originalUrl || request.url`), so an absolute `Location` can only be produced when that
+   * path is itself an absolute URL (e.g. an upstream proxy rewrote it). When it is just a path the
+   * `Location` is necessarily relative — the request headers are not threaded through the protocol
+   * methods. Use the fetch/hono handlers (which receive `request.url` with the origin) or set
+   * `useRelativeLocation: true` explicitly for relative URLs everywhere.
+   * @param requestUrl Request URL string (path-only on Node unless rewritten to an absolute URL).
+   * @param file File object containing ID
+   * @returns Constructed file URL for TUS protocol
+   */
   protected buildFileUrlForTus(requestUrl: string, file: TFile): string;
 }
 export { type AsyncHandler, type Handlers, type MethodHandler, Multipart, Rest, Tus, type UploadOptions };