import { U as UploadFile, j as UploadResponse } from "../../../packem_shared/storage.d-C9EdfTf1.js";
import { H as Handlers, R as ResponseFile, a as ResponseList, U as UploadOptions } from "../../../packem_shared/types.d-D6Jkz0Sp.js";
export type { A as AsyncHandler, B as BaseHandler, M as MethodHandler, b as RequestEvent, c as UploadErrorEvent, d as UploadEvent } from "../../../packem_shared/types.d-D6Jkz0Sp.js";
import { B as BaseHandlerCore } from "../../../packem_shared/tus-base.d-Dgnbivbj.js";
export { T as TUS_RESUMABLE, a as TUS_VERSION } from "../../../packem_shared/tus-base.d-Dgnbivbj.js";
import 'node:stream';
import 'node:timers';
import 'node:crypto';
import 'node:http';
import 'lru-cache';
import 'node:events';
import '@visulima/pagination';
import "../../../packem_shared/media-transformer.d-Co37isNg.js";
import "../../../packem_shared/types.d-D1TIRqKW.js";
/**
 * Base handler for Web API Fetch platform (Request/Response).
 * Extends BaseHandlerCore with Fetch-specific request/response handling.
 * @template TFile The file type used by this handler.
 */
declare abstract class BaseHandlerFetch<TFile extends UploadFile> extends BaseHandlerCore<TFile> {
  /**
   * Limiting enabled HTTP method handler.
   */
  static readonly methods: Handlers[];
  /**
   * Map of registered HTTP method handlers.
   */
  protected registeredHandlers: Map<string, (request: Request) => Promise<ResponseFile<TFile> | ResponseList<TFile>>>;
  constructor(options: UploadOptions<TFile>);
  /**
   * Gets the registered handlers map.
   * @returns Map of registered handlers.
   */
  get handlers(): Map<string, (request: Request) => Promise<ResponseFile<TFile> | ResponseList<TFile>>>;
  /**
   * Handles Web API Fetch requests (for Hono, Cloudflare Workers, etc.).
   * @param request Web API Request object.
   * @returns Promise resolving to Web API Response.
   */
  fetch(request: Request): Promise<globalThis.Response>;
  /**
   * Compose and register HTTP method handlers.
   * Subclasses should override this to register their specific handlers.
   */
  protected abstract compose(): void;
  /**
   * Handle the response from handlers for fetch requests and convert to Web API Response.
   * @param request Web API Request object
   * @param file Response file or list from handler
   * @returns Promise resolving to Web API Response object
   */
  protected handleFetchResponse(request: Request, file: ResponseFile<TFile> | ResponseList<TFile>): Promise<globalThis.Response>;
  /**
   * Convert headers to Web API Headers format by flattening arrays and converting to strings.
   * @param headers Headers object with potentially array values
   * @returns Headers object with all values as strings
   */
  protected convertHeaders(headers: Record<string, number | string | string[]>): Record<string, string>;
  /**
   * Create Web API Response from UploadResponse object.
   * @param uploadResponse Upload response containing body, headers, and status code
   * @returns Web API Response object
   */
  protected createResponse(uploadResponse: UploadResponse): globalThis.Response;
  /**
   * Create error Response from Error object with appropriate status code and message.
   * @param error Error object to convert to HTTP error response
   * @returns Web API Response object with error details
   */
  protected createErrorResponse(error: Error): Promise<globalThis.Response>;
  /**
   * Build file URL from request and file data.
   * @param request Web API Request object
   * @param file File object containing ID and content type
   * @returns Constructed file URL with extension based on content type
   */
  protected buildFileUrl(request: Request, file: TFile): string;
  /**
   * Negotiates content type based on Accept header and supported formats.
   * @param request Web API 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: Request, supportedTypes: string[]): string | undefined;
}
/**
 * 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 override 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;
}
/**
 * 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 override 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>>;
}
/**
 * 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);
 * });
 * ```
 */
declare class Tus<TFile extends UploadFile> extends BaseHandlerFetch<TFile> {
  /**
   * Limiting enabled http method handler
   */
  static override readonly methods: Handlers[];
  private readonly tusBase;
  constructor(options: UploadOptions<TFile>);
  /**
   * Web API fetch entrypoint. Wraps the base implementation to ensure every TUS
   * response — success and error alike — carries the `Tus-Resumable` header,
   * which the protocol requires on all responses.
   */
  override fetch(request: Request): Promise<globalThis.Response>;
  /**
   * 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;
}
export { type Handlers, Multipart, RestFetch as Rest, Tus, type UploadOptions };