@visulima/storage 1.0.0-alpha.1 → 1.0.0-alpha.10

package/dist/handler/multipart/multipart.d.ts

@@ -0,0 +1,49 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { UploadFile } from "../../storage/utils/index.d.ts";
+import BaseHandlerNode from "../base/base-handler-node.d.ts";
+import type { Handlers, ResponseFile, UploadOptions } from "../types.d.ts";
+/**
+ * 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
+     */
+    static readonly methods: Handlers[];
+    private readonly multipartBase;
+    /**
+     * Maximum file size allowed for multipart uploads
+     */
+    private maxFileSize;
+    /**
+     * 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.
+     */
+    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(request: NodeRequest): Promise<ResponseFile<TFile>>;
+    /**
+     * Compose and register HTTP method handlers.
+     */
+    protected compose(): void;
+}
+export default Multipart;

package/dist/handler/rest/rest-base.d.ts

@@ -0,0 +1,106 @@
+import type { FileInit, UploadFile } from "../../storage/utils/index.d.ts";
+import type { ResponseFile, ResponseList } from "../types.d.ts";
+/**
+ * Base class containing shared REST API business logic.
+ * Platform-agnostic - contains no Node.js or Web API specific code.
+ * @template TFile The file type used by this handler.
+ */
+declare abstract class RestBase<TFile extends UploadFile> {
+    /**
+     * Handle single file deletion.
+     * @param id File ID to delete
+     * @returns Promise resolving to ResponseFile with deletion result
+     */
+    deleteSingle(id: string): Promise<ResponseFile<TFile>>;
+    /**
+     * Handle file creation (POST).
+     * @param config File initialization config
+     * @param isChunkedUpload Whether this is a chunked upload initialization
+     * @param requestUrl Request URL for Location header
+     * @param bodyStream Request body stream (for non-chunked uploads)
+     * @param contentLength Content length (for non-chunked uploads)
+     * @returns Promise resolving to ResponseFile with upload result
+     */
+    handlePost(config: FileInit, isChunkedUpload: boolean, requestUrl: string, bodyStream: unknown, contentLength: number): Promise<ResponseFile<TFile>>;
+    /**
+     * Handle file update or creation (PUT).
+     * @param id File ID from URL
+     * @param config File initialization config (for new files)
+     * @param requestUrl Request URL for Location header
+     * @param bodyStream Request body stream
+     * @param contentLength Content length
+     * @param metadata Optional metadata to merge (for updates)
+     * @returns Promise resolving to ResponseFile with upload result
+     */
+    handlePut(id: string, config: FileInit, requestUrl: string, bodyStream: unknown, contentLength: number, metadata?: Record<string, unknown>): Promise<ResponseFile<TFile>>;
+    /**
+     * Handle chunked upload chunk (PATCH).
+     * @param id File ID from URL
+     * @param chunkOffset Chunk offset in bytes
+     * @param contentLength Chunk content length
+     * @param chunkChecksum Optional chunk checksum
+     * @param requestUrl Request URL for Location header
+     * @param bodyStream Request body stream
+     * @returns Promise resolving to ResponseFile with upload progress
+     */
+    handlePatch(id: string, chunkOffset: number, contentLength: number, chunkChecksum: string | undefined, requestUrl: string, bodyStream: unknown): Promise<ResponseFile<TFile>>;
+    /**
+     * Handle file metadata retrieval (HEAD).
+     * @param id File ID from URL
+     * @returns Promise resolving to ResponseFile with metadata headers
+     */
+    handleHead(id: string): Promise<ResponseFile<TFile>>;
+    /**
+     * Handle OPTIONS request with REST API capabilities.
+     * @param methods Array of supported HTTP methods
+     * @param maxUploadSize Maximum upload size
+     * @returns ResponseFile with CORS headers
+     */
+    handleOptions(methods: string[], maxUploadSize: number): ResponseFile<TFile>;
+    /**
+     * Handle batch file deletion.
+     * @param ids Array of file IDs to delete
+     * @returns Promise resolving to ResponseList with deletion results
+     */
+    deleteBatch(ids: string[]): Promise<ResponseList<TFile>>;
+    /**
+     * Storage instance for file operations.
+     */
+    protected get storage(): {
+        create: (config: FileInit) => Promise<TFile>;
+        delete: (options: {
+            id: string;
+        }) => Promise<TFile>;
+        deleteBatch: (ids: string[]) => Promise<{
+            failed: {
+                error: string;
+                id: string;
+            }[];
+            failedCount: number;
+            successful: TFile[];
+            successfulCount: number;
+        }>;
+        getMeta: (id: string) => Promise<TFile>;
+        maxUploadSize: number;
+        update: (options: {
+            id: string;
+        }, updates: {
+            metadata?: Record<string, unknown>;
+            status?: string;
+        }) => Promise<void>;
+        write: (options: {
+            body: unknown;
+            contentLength: number;
+            id: string;
+            start: number;
+        }) => Promise<TFile>;
+    };
+    /**
+     * Build file URL from request URL 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 buildFileUrl(_requestUrl: string, _file: TFile): string;
+}
+export default RestBase;

package/dist/handler/rest/rest-fetch.d.ts

@@ -0,0 +1,88 @@
+import type { UploadFile } from "../../storage/utils/index.d.ts";
+import BaseHandlerFetch from "../base/base-handler-fetch.d.ts";
+import type { Handlers, ResponseFile, ResponseList, UploadOptions } from "../types.d.ts";
+/**
+ * REST API handler for direct binary file uploads (Web API Fetch version).
+ *
+ * This handler provides a clean REST interface for file operations using Web API Request/Response:
+ * - 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 RestFetch({
+ *   storage,
+ * });
+ *
+ * // Use with Hono, Cloudflare Workers, etc.
+ * app.all('/files/*', async (c) => {
+ *   return rest.fetch(c.req.raw);
+ * });
+ * ```
+ */
+declare class RestFetch<TFile extends UploadFile> extends BaseHandlerFetch<TFile> {
+    /**
+     * Limiting enabled http method handler
+     */
+    static readonly methods: Handlers[];
+    private readonly restBase;
+    constructor(options: UploadOptions<TFile>);
+    /**
+     * Compose and register HTTP method handlers.
+     */
+    protected compose(): void;
+    /**
+     * Creates a new file via POST request with raw binary data.
+     * Supports both full file uploads and chunked upload initialization.
+     * @param request Web API Request with file data.
+     * @returns Promise resolving to ResponseFile with upload result.
+     */
+    post(request: Request): Promise<ResponseFile<TFile>>;
+    /**
+     * Create or update a file via PUT request.
+     * Requires file ID in the URL path.
+     * @param request Web API Request with file ID and data
+     * @returns Promise resolving to ResponseFile with upload result
+     */
+    put(request: Request): 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 Web API Request with file ID(s)
+     * @returns Promise resolving to ResponseFile (single) or ResponseList (batch) with deletion result
+     */
+    delete(request: Request): 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 Web API Request with chunk data.
+     * @returns Promise resolving to ResponseFile with upload progress.
+     */
+    patch(request: Request): Promise<ResponseFile<TFile>>;
+    /**
+     * Get file metadata via HEAD request.
+     * For chunked uploads, also returns upload progress information.
+     * @param request Web API Request with file ID
+     * @returns Promise resolving to ResponseFile with metadata headers
+     */
+    head(request: Request): Promise<ResponseFile<TFile>>;
+    /**
+     * Handle OPTIONS requests with REST API capabilities.
+     * @param _request Web API Request
+     * @returns Promise resolving to ResponseFile with CORS headers
+     */
+    options(_request: Request): Promise<ResponseFile<TFile>>;
+    /**
+     * Retrieves a file or list of files based on the request path.
+     * Delegates to BaseHandlerFetch.fetch() method.
+     * @param _request Web API Request
+     * @returns Promise resolving to Web API Response
+     */
+    get(_request: Request): Promise<ResponseFile<TFile> | ResponseList<TFile>>;
+}
+export default RestFetch;

package/dist/handler/rest/rest.d.ts

@@ -0,0 +1,93 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { UploadFile } from "../../storage/utils/index.d.ts";
+import BaseHandlerNode from "../base/base-handler-node.d.ts";
+import type { Handlers, ResponseFile, ResponseList, UploadOptions } from "../types.d.ts";
+/**
+ * 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
+     */
+    static readonly methods: Handlers[];
+    private readonly restBase;
+    constructor(options: UploadOptions<TFile>);
+    /**
+     * Compose and register HTTP method handlers.
+     */
+    protected 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
+     */
+    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.
+     */
+    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
+     */
+    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(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.
+     */
+    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
+     */
+    head(request: NodeRequest): Promise<ResponseFile<TFile>>;
+    /**
+     * Handle OPTIONS requests with REST API capabilities.
+     * @returns Promise resolving to ResponseFile with CORS headers
+     */
+    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.
+     */
+    get(request: NodeRequest, response: NodeResponse): Promise<ResponseFile<TFile> | ResponseList<TFile>>;
+}
+export default Rest;

package/dist/handler/tus/tus-base.d.ts

@@ -0,0 +1,152 @@
+import type { Checksum, FileInit, UploadFile } from "../../storage/utils/index.d.ts";
+import { Metadata } from "../../storage/utils/index.d.ts";
+import type { Headers } from "../../utils/types.d.ts";
+import type { ResponseFile } from "../types.d.ts";
+/**
+ * Parse TUS protocol metadata string into object.
+ * @param encoded Base64-encoded metadata string (optional, defaults to empty string)
+ * @returns Parsed metadata object with decoded values
+ */
+export declare const parseMetadata: (encoded?: string) => Metadata;
+/**
+ * Serialize metadata object to TUS protocol format.
+ * @param object Metadata object to serialize
+ * @returns Base64-encoded metadata string in TUS format
+ */
+export declare const serializeMetadata: (object: Metadata | Record<string, unknown> | undefined) => string;
+/**
+ * Base class containing shared TUS protocol business logic.
+ * Platform-agnostic - contains no Node.js or Web API specific code.
+ * @template TFile The file type used by this handler.
+ */
+export declare abstract class TusBase<TFile extends UploadFile> {
+    /**
+     * Storage instance for file operations.
+     */
+    protected get storage(): {
+        checkIfExpired: (file: TFile) => Promise<void>;
+        checksumTypes: string[];
+        config: {
+            useRelativeLocation?: boolean;
+        };
+        create: (config: FileInit) => Promise<TFile>;
+        delete: (options: {
+            id: string;
+        }) => Promise<TFile>;
+        getMeta: (id: string) => Promise<TFile>;
+        getStream?: (options: {
+            id: string;
+        }) => Promise<{
+            size?: number;
+            stream: unknown;
+        }>;
+        maxUploadSize: number;
+        tusExtension: string[];
+        update: (options: {
+            id: string;
+        }, updates: {
+            id?: string;
+            metadata?: Record<string, unknown>;
+            size?: number;
+        }) => Promise<TFile>;
+        write: (options: {
+            body: unknown;
+            checksum?: string;
+            checksumAlgorithm?: string;
+            contentLength: number;
+            id: string;
+            start: number;
+        }) => Promise<TFile>;
+    };
+    /**
+     * Whether to disable termination for finished uploads.
+     * Must be implemented by subclasses via getter.
+     */
+    protected abstract get disableTerminationForFinishedUploads(): boolean;
+    /**
+     * Build file URL from request URL and file data.
+     * @param _requestUrl Request URL string
+     * @param _file File object containing ID
+     * @returns Constructed file URL for TUS protocol
+     */
+    protected buildFileUrl(_requestUrl: string, _file: TFile): string;
+    /**
+     * Handle OPTIONS request with TUS protocol capabilities.
+     * @param methods Array of supported HTTP methods
+     * @returns ResponseFile with TUS headers
+     */
+    handleOptions(methods: string[]): ResponseFile<TFile>;
+    /**
+     * Handle TUS POST (create upload).
+     * @param uploadLength Upload length header value
+     * @param uploadDeferLength Upload defer length header value
+     * @param uploadConcat Upload concat header value
+     * @param metadataHeader Upload metadata header value
+     * @param requestUrl Request URL for Location header
+     * @param bodyStream Request body stream (for creation-with-upload)
+     * @param contentLength Content length (for creation-with-upload)
+     * @param contentType Content type (for creation-with-upload)
+     * @returns Promise resolving to ResponseFile with upload result
+     */
+    handlePost(uploadLength: string | undefined, uploadDeferLength: string | undefined, uploadConcat: string | undefined, metadataHeader: string | undefined, requestUrl: string, bodyStream: unknown, contentLength: number, contentType: string): Promise<ResponseFile<TFile>>;
+    /**
+     * Handle TUS PATCH (write chunk).
+     * @param id File ID from URL
+     * @param uploadOffset Upload offset header value
+     * @param uploadLength Optional upload length header value (for defer-length)
+     * @param metadataHeader Optional upload metadata header value
+     * @param checksum Optional checksum
+     * @param checksumAlgorithm Optional checksum algorithm
+     * @param requestUrl Request URL for Location header
+     * @param bodyStream Request body stream
+     * @param contentLength Content length
+     * @returns Promise resolving to ResponseFile with upload progress
+     */
+    handlePatch(id: string, uploadOffset: number, uploadLength: string | undefined, metadataHeader: string | undefined, checksum: string | undefined, checksumAlgorithm: string | undefined, _requestUrl: string, bodyStream: unknown, contentLength: number): Promise<ResponseFile<TFile>>;
+    /**
+     * Handle TUS HEAD (get upload status).
+     * @param id File ID from URL
+     * @returns Promise resolving to ResponseFile with upload status headers
+     */
+    handleHead(id: string): Promise<ResponseFile<TFile>>;
+    /**
+     * Handle TUS GET (get upload metadata).
+     * @param id File ID from URL
+     * @returns Promise resolving to ResponseFile with file metadata as JSON
+     */
+    handleGet(id: string): Promise<ResponseFile<TFile>>;
+    /**
+     * Handle TUS DELETE (terminate upload).
+     * @param id File ID from URL
+     * @returns Promise resolving to ResponseFile with deletion confirmation
+     */
+    handleDelete(id: string): Promise<ResponseFile<TFile>>;
+    /**
+     * Build TUS protocol headers including required Tus-Resumable and optional Upload-Expires.
+     * @param file Upload file object with metadata
+     * @param headers Additional headers to include
+     * @returns Headers object with TUS protocol headers
+     */
+    protected buildHeaders(file: UploadFile, headers?: Headers): Headers;
+    /**
+     * Extract checksum algorithm and value from Upload-Checksum header.
+     * @param checksumHeader Upload-Checksum header value
+     * @returns Object containing checksum algorithm and value
+     */
+    extractChecksum(checksumHeader: string | undefined): Checksum;
+    /**
+     * Validate Tus-Resumable header value.
+     * @param tusResumable Tus-Resumable header value
+     * @throws {Error} 412 if version doesn't match or header is missing
+     */
+    validateTusResumableHeader(tusResumable: string | undefined): void;
+    /**
+     * Concatenate partial uploads into a final upload.
+     * @param finalFile Final file that will contain concatenated content
+     * @param partialFiles Array of partial upload files to concatenate
+     * @returns Promise resolving when concatenation is complete
+     */
+    protected concatenateFiles(finalFile: TFile, partialFiles: TFile[]): Promise<void>;
+}
+export declare const TUS_RESUMABLE: string;
+export declare const TUS_VERSION: string;

package/dist/handler/tus/tus-fetch.d.ts

@@ -0,0 +1,72 @@
+import type { UploadFile } from "../../storage/utils/index.d.ts";
+import BaseHandlerFetch from "../base/base-handler-fetch.d.ts";
+import type { Handlers, ResponseFile, UploadOptions } from "../types.d.ts";
+export { TUS_RESUMABLE, TUS_VERSION } from "./tus-base.d.ts";
+/**
+ * TUS resumable upload protocol handler (Web API Fetch version).
+ *
+ * [tus resumable upload protocol](https://github.com/tus/tus-resumable-upload-protocol/blob/master/protocol.md)
+ * @example
+ * ```ts
+ * const tus = new TusFetch({storage});
+ *
+ * // Use with Hono, Cloudflare Workers, etc.
+ * app.all('/files/*', async (c) => {
+ *   return tus.fetch(c.req.raw);
+ * });
+ * ```
+ */
+export declare class Tus<TFile extends UploadFile> extends BaseHandlerFetch<TFile> {
+    /**
+     * Limiting enabled http method handler
+     */
+    static readonly methods: Handlers[];
+    private readonly tusBase;
+    constructor(options: UploadOptions<TFile>);
+    /**
+     * Handle OPTIONS requests with TUS protocol capabilities.
+     * @returns Promise resolving to ResponseFile with TUS headers
+     */
+    options(): Promise<ResponseFile<TFile>>;
+    /**
+     * Creates a new TUS upload and optionally starts uploading data.
+     * @param request Web API Request with TUS headers.
+     * @returns Promise resolving to ResponseFile with upload location and offset.
+     */
+    post(request: Request): Promise<ResponseFile<TFile>>;
+    /**
+     * Write a chunk of data to an existing TUS upload.
+     * @param request Web API Request with chunk data and TUS headers
+     * @returns Promise resolving to ResponseFile with updated offset
+     */
+    patch(request: Request): Promise<ResponseFile<TFile>>;
+    /**
+     * Get current upload offset and metadata for TUS resumable uploads.
+     * @param request Web API Request with upload ID
+     * @returns Promise resolving to ResponseFile with upload-offset and metadata headers
+     */
+    head(request: Request): Promise<ResponseFile<TFile>>;
+    /**
+     * Get TUS upload metadata and current status.
+     * @param request Web API Request with upload ID
+     * @returns Promise resolving to ResponseFile with file metadata as JSON
+     */
+    get(request: Request): Promise<ResponseFile<TFile>>;
+    /**
+     * Delete a TUS upload and its associated data.
+     * @param request Web API Request with upload ID
+     * @returns Promise resolving to ResponseFile with deletion confirmation
+     */
+    delete(request: Request): Promise<ResponseFile<TFile>>;
+    /**
+     * Compose and register HTTP method handlers.
+     */
+    protected compose(): void;
+    /**
+     * Build file URL for TUS uploads (without file extension).
+     * @param requestUrl Request URL string
+     * @param file File object containing ID
+     * @returns Constructed file URL for TUS protocol
+     */
+    protected buildFileUrlForTus(requestUrl: string, file: TFile): string;
+}

package/dist/handler/tus/tus.d.ts

@@ -0,0 +1,78 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { UploadFile } from "../../storage/utils/index.d.ts";
+import type { UploadResponse } from "../../utils/types.d.ts";
+import BaseHandlerNode from "../base/base-handler-node.d.ts";
+import type { Handlers, ResponseFile, UploadOptions } from "../types.d.ts";
+export { TUS_RESUMABLE, TUS_VERSION } from "./tus-base.d.ts";
+/**
+ * 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);
+ * ```
+ */
+export declare class Tus<TFile extends UploadFile, NodeRequest extends IncomingMessage = IncomingMessage, NodeResponse extends ServerResponse = ServerResponse> extends BaseHandlerNode<TFile, NodeRequest, NodeResponse> {
+    /**
+     * Limiting enabled http method handler
+     */
+    static readonly methods: Handlers[];
+    disableTerminationForFinishedUploads: boolean;
+    private readonly tusBase;
+    constructor(options: UploadOptions<TFile>);
+    /**
+     * Handle OPTIONS requests with TUS protocol capabilities.
+     * @returns Promise resolving to ResponseFile with TUS headers
+     */
+    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.
+     */
+    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
+     */
+    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
+     */
+    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(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(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
+     */
+    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).
+     * @param requestUrl Request URL string
+     * @param file File object containing ID
+     * @returns Constructed file URL for TUS protocol
+     */
+    protected buildFileUrlForTus(requestUrl: string, file: TFile): string;
+}