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

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

@@ -0,0 +1,137 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { Readable } from "node:stream";
+import type { UploadFile } from "../../storage/utils/index.d.ts";
+import type { UploadResponse } from "../../utils/types.d.ts";
+import type { AsyncHandler, Handlers, MethodHandler, ResponseFile, ResponseList, UploadOptions } from "../types.d.ts";
+import BaseHandlerCore from "./base-handler-core.d.ts";
+/**
+ * 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.
+     */
+    static readonly methods: 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.
+     */
+    get handlers(): Map<string, AsyncHandler<NodeRequest, NodeResponse>>;
+    /**
+     * 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.
+     */
+    upload: (request: NodeRequest, response: NodeResponse, next?: () => void) => Promise<void>;
+    /**
+     * 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.
+     */
+    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, }: {
+        headers?: Record<string, string | number>;
+        range?: {
+            end: number;
+            start: number;
+        };
+        size?: number;
+        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
+     */
+    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
+     */
+    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.
+     */
+    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
+     */
+    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.
+     */
+    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.
+     */
+    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.
+     */
+    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
+     */
+    protected checkForUndefinedIdOrPath(error: unknown): void;
+}
+export default BaseHandlerNode;

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

@@ -0,0 +1,4 @@
+export { default as Multipart } from "../../multipart/multipart-fetch.d.ts";
+export { default as Rest } from "../../rest/rest-fetch.d.ts";
+export { Tus, TUS_RESUMABLE, TUS_VERSION } from "../../tus/tus-fetch.d.ts";
+export type { AsyncHandler, BaseHandler, Handlers, MethodHandler, RequestEvent, UploadErrorEvent, UploadEvent, UploadOptions } from "../../types.d.ts";

package/dist/handler/http/fetch/index.js

@@ -0,0 +1,4 @@
+export { default as Multipart } from '../../../packem_shared/Multipart-CDDlDOs7.js';
+export { default as Rest } from '../../../packem_shared/Rest-D14vM7aJ.js';
+export { Tus } from '../../../packem_shared/Tus-Cjz87bpz.js';
+export { TUS_RESUMABLE, TUS_VERSION } from '../../../packem_shared/TUS_RESUMABLE-Dtfsffnj.js';

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

@@ -0,0 +1,67 @@
+import type { Hono } from "hono";
+import type { UploadFile } from "../../../storage/utils/index.d.ts";
+import type { UploadOptions } from "../../types.d.ts";
+/**
+ * Registers upload handler routes on a Hono app instance.
+ * Automatically registers all required HTTP methods for the specified handler type.
+ * @param app Hono app instance to register routes on
+ * @param config Handler configuration including storage, type, and path
+ * @example
+ * ```ts
+ * import { Hono } from "hono";
+ * import { DiskStorage } from "@visulima/storage";
+ * import { createHonoHandler } from "@visulima/storage/handler/http/hono";
+ *
+ * const app = new Hono();
+ * const storage = new DiskStorage({ directory: "./uploads" });
+ *
+ * // Multipart handler - automatically registers POST, GET, DELETE, OPTIONS
+ * createHonoHandler(app, {
+ *   path: "/files",
+ *   storage,
+ *   type: "multipart"
+ * });
+ * ```
+ * @example
+ * ```ts
+ * import { Hono } from "hono";
+ * import { DiskStorage } from "@visulima/storage";
+ * import { createHonoHandler } from "@visulima/storage/handler/http/hono";
+ *
+ * const app = new Hono();
+ * const storage = new DiskStorage({ directory: "./uploads" });
+ *
+ * // REST handler - automatically registers POST, PUT, PATCH, GET, HEAD, DELETE, OPTIONS
+ * createHonoHandler(app, {
+ *   path: "/files-rest",
+ *   storage,
+ *   type: "rest"
+ * });
+ * ```
+ * @example
+ * ```ts
+ * import { Hono } from "hono";
+ * import { DiskStorage } from "@visulima/storage";
+ * import { createHonoHandler } from "@visulima/storage/handler/http/hono";
+ *
+ * const app = new Hono();
+ * const storage = new DiskStorage({ directory: "./uploads" });
+ *
+ * // TUS handler - automatically registers POST, PATCH, HEAD, GET, DELETE, OPTIONS
+ * createHonoHandler(app, {
+ *   path: "/files-tus",
+ *   storage,
+ *   type: "tus"
+ * });
+ * ```
+ */
+export declare const createStorageHandler: <TFile extends UploadFile>(app: Hono, config: HonoHandlerConfig<TFile>) => void;
+/**
+ * Configuration for Hono handler.
+ */
+export interface HonoHandlerConfig<TFile extends UploadFile> extends UploadOptions<TFile> {
+    /** Base path for the routes (e.g., "/files" or "/api/upload") */
+    path: string;
+    /** Handler type to use */
+    type: "multipart" | "rest" | "tus";
+}

package/dist/handler/http/hono/index.js

@@ -0,0 +1,65 @@
+import Multipart from '../../../packem_shared/Multipart-CDDlDOs7.js';
+import RestFetch from '../../../packem_shared/Rest-D14vM7aJ.js';
+import { Tus } from '../../../packem_shared/Tus-Cjz87bpz.js';
+
+const createHandlerFunction = (handler) => async (c) => {
+  try {
+    const request = c.req.raw;
+    return await handler.fetch(request);
+  } catch (error) {
+    const errorObject = error;
+    const statusCode = errorObject.statusCode || (errorObject.status ? Number.parseInt(errorObject.status, 10) : void 0) || 500;
+    return Response.json({ error: errorObject.message || "Request failed" }, { status: statusCode });
+  }
+};
+const createStorageHandler = (app, config) => {
+  const { path, type, ...handlerConfig } = config;
+  let handler;
+  switch (type) {
+    case "multipart": {
+      handler = new Multipart(handlerConfig);
+      break;
+    }
+    case "rest": {
+      handler = new RestFetch(handlerConfig);
+      break;
+    }
+    case "tus": {
+      handler = new Tus(handlerConfig);
+      break;
+    }
+    default: {
+      throw new Error(`Unknown handler type: ${String(type ?? "unknown")}`);
+    }
+  }
+  const handlerFunction = createHandlerFunction(handler);
+  switch (type) {
+    case "multipart": {
+      app.post(path, handlerFunction);
+      app.get(`${path}/:id?/:metadata?`, handlerFunction);
+      app.delete(`${path}/:id`, handlerFunction);
+      app.on("OPTIONS", path, handlerFunction);
+      break;
+    }
+    case "rest": {
+      app.post(path, handlerFunction);
+      app.put(`${path}/:id`, handlerFunction);
+      app.patch(`${path}/:id`, handlerFunction);
+      app.get(`${path}/:id?`, handlerFunction);
+      app.on("HEAD", `${path}/:id`, handlerFunction);
+      app.delete(`${path}/:id?`, handlerFunction);
+      app.on("OPTIONS", path, handlerFunction);
+      break;
+    }
+    case "tus": {
+      app.all(path, handlerFunction);
+      app.all(`${path}/:id`, handlerFunction);
+      break;
+    }
+    default: {
+      throw new Error(`Unknown handler type: ${String(type)}`);
+    }
+  }
+};
+
+export { createStorageHandler };

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

@@ -0,0 +1,61 @@
+import type { NextRequest } from "next/server.d.ts";
+import { NextResponse } from "next/server.d.ts";
+import type { UploadFile } from "../../../storage/utils/index.d.ts";
+import type { UploadOptions } from "../../types.d.ts";
+/**
+ * Configuration for Next.js handler.
+ */
+export interface NextjsHandlerConfig<TFile extends UploadFile> extends UploadOptions<TFile> {
+    /** Handler type to use */
+    type: "multipart" | "rest" | "tus";
+}
+/**
+ * Next.js route handler that automatically exports the correct HTTP methods for each handler type.
+ * @example
+ * ```ts
+ * // app/api/upload/multipart/route.ts
+ * import { DiskStorage } from "@visulima/storage";
+ * import { createHandler } from "@visulima/storage/handler/http/nextjs";
+ *
+ * const storage = new DiskStorage({ directory: "./uploads" });
+ * const handler = createHandler({ storage, type: "multipart" });
+ *
+ * export const POST = handler;
+ * export const DELETE = handler;
+ * export const GET = handler;
+ * export const OPTIONS = handler;
+ * ```
+ * @example
+ * ```ts
+ * // app/api/upload/rest/route.ts
+ * import { DiskStorage } from "@visulima/storage";
+ * import { createHandler } from "@visulima/storage/handler/http/nextjs";
+ *
+ * const storage = new DiskStorage({ directory: "./uploads" });
+ * const handler = createHandler({ storage, type: "rest" });
+ *
+ * export const POST = handler;
+ * export const PUT = handler;
+ * export const PATCH = handler;
+ * export const GET = handler;
+ * export const HEAD = handler;
+ * export const DELETE = handler;
+ * export const OPTIONS = handler;
+ * ```
+ * @example
+ * ```ts
+ * // app/api/upload/tus/route.ts
+ * import { DiskStorage } from "@visulima/storage";
+ * import { createHandler } from "@visulima/storage/handler/http/nextjs";
+ *
+ * const storage = new DiskStorage({ directory: "./uploads" });
+ * const handler = createHandler({ storage, type: "tus" });
+ *
+ * export const POST = handler;
+ * export const PATCH = handler;
+ * export const HEAD = handler;
+ * export const DELETE = handler;
+ * export const OPTIONS = handler;
+ * ```
+ */
+export declare const createHandler: <TFile extends UploadFile>(config: NextjsHandlerConfig<TFile>) => ((request: NextRequest) => Promise<NextResponse>);

package/dist/handler/http/nextjs/index.js

@@ -0,0 +1,37 @@
+import { NextResponse } from 'next/server.js';
+import Multipart from '../../../packem_shared/Multipart-CDDlDOs7.js';
+import RestFetch from '../../../packem_shared/Rest-D14vM7aJ.js';
+import { Tus } from '../../../packem_shared/Tus-Cjz87bpz.js';
+
+const createHandler = (config) => {
+  let handler;
+  switch (config.type) {
+    case "multipart": {
+      handler = new Multipart(config);
+      break;
+    }
+    case "rest": {
+      handler = new RestFetch(config);
+      break;
+    }
+    case "tus": {
+      handler = new Tus(config);
+      break;
+    }
+    default: {
+      throw new Error(`Unknown handler type: ${String(config.type ?? "unknown")}`);
+    }
+  }
+  const nextjsHandler = async (request) => {
+    try {
+      return await handler.fetch(request);
+    } catch (error) {
+      const errorObject = error;
+      const statusCode = errorObject.statusCode || (errorObject.status ? Number.parseInt(errorObject.status, 10) : void 0) || 500;
+      return NextResponse.json({ error: errorObject.message || "Request failed" }, { status: statusCode });
+    }
+  };
+  return nextjsHandler;
+};
+
+export { createHandler };

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

@@ -0,0 +1,4 @@
+export { default as Multipart } from "../../multipart/multipart.d.ts";
+export { default as Rest } from "../../rest/rest.d.ts";
+export { Tus, TUS_RESUMABLE, TUS_VERSION } from "../../tus/tus.d.ts";
+export type { AsyncHandler, BaseHandler, Handlers, MethodHandler, RequestEvent, UploadErrorEvent, UploadEvent, UploadOptions } from "../../types.d.ts";

package/dist/handler/http/node/index.js

@@ -0,0 +1,8 @@
+import Multipart from '../../../packem_shared/Multipart-vxBL2VXm.js';
+import Rest from '../../../packem_shared/Rest-CEj3EhMj.js';
+import { Tus } from '../../../packem_shared/Tus-WOVg-YnB.js';
+export { TUS_RESUMABLE, TUS_VERSION } from '../../../packem_shared/TUS_RESUMABLE-Dtfsffnj.js';
+
+
+
+export { Multipart, Rest, Tus };

package/dist/handler/http/solid-start/index.d.ts

@@ -0,0 +1,60 @@
+import type { APIEvent } from "@solidjs/start/server";
+import type { UploadFile } from "../../../storage/utils/index.d.ts";
+import type { UploadOptions } from "../../types.d.ts";
+/**
+ * Configuration for SolidStart handler.
+ */
+export interface SolidStartHandlerConfig<TFile extends UploadFile> extends UploadOptions<TFile> {
+    /** Handler type to use */
+    type: "multipart" | "rest" | "tus";
+}
+/**
+ * SolidStart API route handler that automatically handles the correct HTTP methods for each handler type.
+ * @example
+ * ```ts
+ * // app/routes/api/upload/multipart.ts
+ * import { DiskStorage } from "@visulima/storage";
+ * import { createSolidStartHandler } from "@visulima/storage/handler/http/solid-start";
+ *
+ * const storage = new DiskStorage({ directory: "./uploads" });
+ * const handler = createSolidStartHandler({ storage, type: "multipart" });
+ *
+ * export const POST = handler;
+ * export const DELETE = handler;
+ * export const GET = handler;
+ * export const OPTIONS = handler;
+ * ```
+ * @example
+ * ```ts
+ * // app/routes/api/upload/rest.ts
+ * import { DiskStorage } from "@visulima/storage";
+ * import { createSolidStartHandler } from "@visulima/storage/handler/http/solid-start";
+ *
+ * const storage = new DiskStorage({ directory: "./uploads" });
+ * const handler = createSolidStartHandler({ storage, type: "rest" });
+ *
+ * export const POST = handler;
+ * export const PUT = handler;
+ * export const PATCH = handler;
+ * export const GET = handler;
+ * export const HEAD = handler;
+ * export const DELETE = handler;
+ * export const OPTIONS = handler;
+ * ```
+ * @example
+ * ```ts
+ * // app/routes/api/upload/tus.ts
+ * import { DiskStorage } from "@visulima/storage";
+ * import { createSolidStartHandler } from "@visulima/storage/handler/http/solid-start";
+ *
+ * const storage = new DiskStorage({ directory: "./uploads" });
+ * const handler = createSolidStartHandler({ storage, type: "tus" });
+ *
+ * export const POST = handler;
+ * export const PATCH = handler;
+ * export const HEAD = handler;
+ * export const DELETE = handler;
+ * export const OPTIONS = handler;
+ * ```
+ */
+export declare const createSolidStartHandler: <TFile extends UploadFile>(config: SolidStartHandlerConfig<TFile>) => ((event: APIEvent) => Promise<Response>);

package/dist/handler/http/solid-start/index.js

@@ -0,0 +1,44 @@
+import Multipart from '../../../packem_shared/Multipart-CDDlDOs7.js';
+import RestFetch from '../../../packem_shared/Rest-D14vM7aJ.js';
+import { Tus } from '../../../packem_shared/Tus-Cjz87bpz.js';
+
+const createSolidStartHandler = (config) => {
+  let handler;
+  switch (config.type) {
+    case "multipart": {
+      handler = new Multipart(config);
+      break;
+    }
+    case "rest": {
+      handler = new RestFetch(config);
+      break;
+    }
+    case "tus": {
+      handler = new Tus(config);
+      break;
+    }
+    default: {
+      throw new Error(`Unknown handler type: ${String(config.type ?? "unknown")}`);
+    }
+  }
+  const solidStartHandler = async (event) => {
+    try {
+      return await handler.fetch(event.request);
+    } catch (error) {
+      const errorObject = error;
+      const statusCode = errorObject.statusCode || (errorObject.status ? Number.parseInt(errorObject.status, 10) : void 0) || 500;
+      return Response.json(
+        { error: errorObject.message || "Request failed" },
+        {
+          headers: {
+            "Content-Type": "application/json"
+          },
+          status: statusCode
+        }
+      );
+    }
+  };
+  return solidStartHandler;
+};
+
+export { createSolidStartHandler };

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

@@ -0,0 +1,84 @@
+import type { FileInit, UploadFile } from "../../storage/utils/index.d.ts";
+import type { ResponseFile } from "../types.d.ts";
+/**
+ * Base class containing shared Multipart 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 MultipartBase<TFile extends UploadFile> {
+    /**
+     * Handle multipart POST (upload file).
+     * @param filePart File part from multipart parser
+     * @param filePart.bytes File bytes data
+     * @param filePart.filename Original filename
+     * @param filePart.mediaType Content type
+     * @param filePart.size File size in bytes
+     * @param metadataParts All parts from multipart parser (for extracting metadata)
+     * @param requestUrl Request URL for Location header
+     * @returns Promise resolving to ResponseFile with upload result
+     */
+    handlePost(filePart: {
+        bytes: unknown;
+        filename?: string;
+        mediaType?: string;
+        size: number;
+    }, metadataParts: {
+        isFile: boolean;
+        name?: string;
+        text?: string;
+    }[], requestUrl: string): Promise<ResponseFile<TFile>>;
+    /**
+     * Handle DELETE (delete file).
+     * @param id File ID from URL
+     * @returns Promise resolving to ResponseFile with deletion result
+     */
+    handleDelete(id: string): Promise<ResponseFile<TFile>>;
+    /**
+     * Storage instance for file operations.
+     */
+    protected get storage(): {
+        create: (config: FileInit) => Promise<TFile>;
+        delete: (options: {
+            id: string;
+        }) => Promise<TFile>;
+        maxUploadSize: number;
+        update: (options: {
+            id: string;
+        }, updates: {
+            metadata?: Record<string, unknown>;
+        }) => Promise<TFile>;
+        write: (options: {
+            body: unknown;
+            contentLength: number;
+            id: string;
+            start: number;
+        }) => Promise<TFile>;
+    };
+    /**
+     * Maximum file size allowed for multipart uploads
+     */
+    protected abstract get maxFileSize(): number;
+    /**
+     * Maximum header size allowed for multipart parser
+     */
+    protected abstract get maxHeaderSize(): number;
+    /**
+     * 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;
+    /**
+     * Create a stream from bytes data.
+     * @param bytes Bytes data (Uint8Array, Buffer, or other)
+     * @returns Stream object
+     */
+    protected abstract createStreamFromBytes(bytes: unknown): unknown;
+    /**
+     * Create an empty stream for signaling completion.
+     * @returns Empty stream object
+     */
+    protected abstract createEmptyStream(): unknown;
+}
+export default MultipartBase;

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

@@ -0,0 +1,64 @@
+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";
+/**
+ * Multipart/form-data upload handler (Web API Fetch version).
+ * @example
+ * ```ts
+ * const multipart = new MultipartFetch({
+ *   storage,
+ *   maxFileSize: 100 * 1024 * 1024, // 100MB
+ * });
+ *
+ * // Use with Hono, Cloudflare Workers, etc.
+ * app.all('/files/*', async (c) => {
+ *   return multipart.fetch(c.req.raw);
+ * });
+ * ```
+ */
+declare class Multipart<TFile extends UploadFile> extends BaseHandlerFetch<TFile> {
+    /**
+     * 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 Web API Request containing multipart data.
+     * @returns Promise resolving to ResponseFile with upload result.
+     */
+    post(request: Request): Promise<ResponseFile<TFile>>;
+    /**
+     * Delete an uploaded file.
+     * @param request Web API Request with file ID
+     * @returns Promise resolving to ResponseFile with deletion result
+     */
+    delete(request: Request): Promise<ResponseFile<TFile>>;
+    /**
+     * Handle OPTIONS requests with CORS headers.
+     * @param _request Web API Request (unused)
+     * @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>>;
+    /**
+     * Compose and register HTTP method handlers.
+     */
+    protected compose(): void;
+}
+export default Multipart;