@visulima/storage 1.0.0-alpha.15 → 1.0.0-alpha.16

package/dist/transformer/index.d.ts

@@ -1,5 +1,62 @@
-export { default as BaseTransformer } from "./base-transformer.d.ts";
-export { default as MediaTransformer } from "./media-transformer.d.ts";
-export type { AudioChannelMixOptions, AudioResampleOptions, AudioTransformationStep, AudioTransformerConfig, AudioTransformOptions, AudioTransformResult, CropOptions, ImageFormat, ImageTransformerConfig, MediaTransformationStep, MediaTransformerConfig, MediaTransformQuery, MediaTransformResult, ResizeOptions, RotateOptions, TransformationStep, TransformOptions, TransformResult, VideoCropOptions, VideoResizeOptions, VideoRotateOptions, VideoTransformationStep, VideoTransformerConfig, VideoTransformOptions, VideoTransformResult, } from "./types.d.ts";
-export { getFormatFromContentType, isKnownContentType, isValidMediaType, validateMediaFile } from "./utils.d.ts";
-export { default as ValidationError } from "./validation-error.d.ts";
+export { type c as AudioChannelMixOptions, type b as AudioResampleOptions, type d as AudioTransformOptions, type a as AudioTransformResult, type e as AudioTransformationStep, type A as AudioTransformerConfig, B as BaseTransformer, type C as CropOptions, type g as ImageFormat, type I as ImageTransformerConfig, type U as MediaTransformQuery, type Q as MediaTransformResult, type W as MediaTransformationStep, type O as MediaTransformerConfig, type R as ResizeOptions, type f as RotateOptions, type h as TransformOptions, type T as TransformResult, type x as TransformationStep, type F as VideoCropOptions, type z as VideoResizeOptions, type H as VideoRotateOptions, type K as VideoTransformOptions, type y as VideoTransformResult, type N as VideoTransformationStep, type V as VideoTransformerConfig } from "../packem_shared/types.d-BPd_JkW1.js";
+export { M as MediaTransformer } from "../packem_shared/media-transformer.d-DeHZkBVx.js";
+import { a as FileReturn } from "../packem_shared/storage.d-BOMUJD96.js";
+import 'node:stream';
+import 'node:crypto';
+import 'node:http';
+import 'lru-cache';
+/**
+* Check if a content type is valid for a specific media type.
+* @param contentType MIME content type string to validate
+* @param expectedType Expected media type ('image', 'video', or 'audio')
+* @returns True if the content type is valid for the expected media type
+*/
+declare const isValidMediaType: (contentType: string | undefined, expectedType: "image" | "video" | "audio") => boolean;
+/**
+* Get format (extension) from content type using mime package.
+* @param contentType MIME content type string to extract format from
+* @returns Format string or undefined if not found
+*/
+declare const getFormatFromContentType: (contentType: string | undefined) => string | undefined;
+/**
+* Validate a media file for a specific type with size and format checks.
+* @param file File to validate
+* @param expectedType Expected media type ('image', 'video', or 'audio')
+* @param config Validation configuration with optional maxSize and supportedFormats
+* @param config.maxSize Maximum allowed file size in bytes
+* @param config.supportedFormats Array of supported file formats
+* @throws Error if validation fails (size exceeded, wrong type, or unsupported format)
+*/
+declare const validateMediaFile: (file: FileReturn, expectedType: "image" | "video" | "audio", config?: {
+  maxSize?: number;
+  supportedFormats?: string[];
+}) => void;
+/**
+* Validate that a content type is known and supported by the mime package.
+* @param contentType MIME content type string to check
+* @returns True if the content type is known and has a registered extension
+*/
+declare const isKnownContentType: (contentType: string | undefined) => boolean;
+/**
+* Custom error class for validation failures
+*/
+declare class ValidationError extends Error {
+  readonly code: string;
+  readonly details: {
+    invalidParams: string[];
+    mediaType: string;
+    suggestions?: string[];
+    validParams: string[];
+  };
+  /**
+  * Creates a new ValidationError instance with detailed error information.
+  * @param message Human-readable error message describing the validation failure
+  * @param code Machine-readable error code for programmatic error handling
+  * @param mediaType The media type where validation failed ('image', 'video', or 'audio')
+  * @param invalidParameters Array of parameter names that were invalid
+  * @param validParameters Array of valid parameter names or values
+  * @param suggestions Optional array of suggested corrections or valid values
+  */
+  constructor(message: string, code: string, mediaType: string, invalidParameters: string[], validParameters: string[], suggestions?: string[]);
+}
+export { ValidationError, getFormatFromContentType, isKnownContentType, isValidMediaType, validateMediaFile };

package/dist/transformer/video-transformer.d.ts

@@ -1,145 +1,147 @@
-import type { BaseStorage } from "../storage/storage.d.ts";
-import type { File, FileReturn } from "../storage/utils/index.d.ts";
-import BaseTransformer from "./base-transformer.d.ts";
-import type { VideoCropOptions, VideoResizeOptions, VideoRotateOptions, VideoTransformationStep, VideoTransformerConfig, VideoTransformOptions, VideoTransformResult } from "./types.d.ts";
+import { F as File, a as FileReturn, B as BaseStorage } from "../packem_shared/storage.d-BOMUJD96.js";
+import { V as VideoTransformerConfig, y as VideoTransformResult, z as VideoResizeOptions, F as VideoCropOptions, H as VideoRotateOptions, K as VideoTransformOptions, N as VideoTransformationStep, B as BaseTransformer } from "../packem_shared/types.d-BPd_JkW1.js";
+import 'node:stream';
+import 'node:crypto';
+import 'node:http';
+import 'lru-cache';
 /**
- * Video transformer that uses storage backends and Mediabunny library to retrieve and transform videos.
- * @template TFile The file type used by this transformer.
- * @template TFileReturn The return type for file retrieval operations.
- *
- * Supports video transformations with query parameters for on-demand video processing.
- * @example
- * ```ts
- * const transformer = new VideoTransformer(storage, {
- *   maxVideoSize: 100 * 1024 * 1024, // 100MB
- *   cache: new Map()
- * });
- *
- * // Programmatic usage - resize a video
- * const result = await transformer.resize('video-id', {
- *   width: 1920,
- *   height: 1080,
- *   fit: 'contain'
- * });
- *
- * // URL-based transformations
- * // GET /files/video-id?width=1280&height=720&fit=cover&bitrate=2000000
- * // GET /files/video-id?codec=vp9&bitrate=1000000
- * ```
- *
- * ## Supported Query Parameters
- *
- * - `width`: Width in pixels (Number)
- * - `height`: Height in pixels (Number)
- * - `fit`: Resize fit mode - cover/contain/fill/inside/outside
- * - `codec`: Video codec - avc/hevc/vp8/vp9/av1
- * - `bitrate`: Video bitrate in bits per second (Number)
- * - `frameRate`: Frame rate in Hz (Number)
- * - `format`: Output format - mp4/webm/mkv/ogg
- */
+* Video transformer that uses storage backends and Mediabunny library to retrieve and transform videos.
+* @template TFile The file type used by this transformer.
+* @template TFileReturn The return type for file retrieval operations.
+*
+* Supports video transformations with query parameters for on-demand video processing.
+* @example
+* ```ts
+* const transformer = new VideoTransformer(storage, {
+*   maxVideoSize: 100 * 1024 * 1024, // 100MB
+*   cache: new Map()
+* });
+*
+* // Programmatic usage - resize a video
+* const result = await transformer.resize('video-id', {
+*   width: 1920,
+*   height: 1080,
+*   fit: 'contain'
+* });
+*
+* // URL-based transformations
+* // GET /files/video-id?width=1280&height=720&fit=cover&bitrate=2000000
+* // GET /files/video-id?codec=vp9&bitrate=1000000
+* ```
+*
+* ## Supported Query Parameters
+*
+* - `width`: Width in pixels (Number)
+* - `height`: Height in pixels (Number)
+* - `fit`: Resize fit mode - cover/contain/fill/inside/outside
+* - `codec`: Video codec - avc/hevc/vp8/vp9/av1
+* - `bitrate`: Video bitrate in bits per second (Number)
+* - `frameRate`: Frame rate in Hz (Number)
+* - `format`: Output format - mp4/webm/mkv/ogg
+*/
 declare class VideoTransformer<TFile extends File = File, TFileReturn extends FileReturn = FileReturn> extends BaseTransformer<VideoTransformerConfig, VideoTransformResult<TFileReturn>, TFile, TFileReturn> {
-    /**
-     * Creates a new VideoTransformer instance.
-     * @param storage The storage backend for retrieving and storing video files.
-     * @param config Configuration options for video transformation including cache settings, codec defaults, and size limits.
-     */
-    constructor(storage: BaseStorage<TFile, TFileReturn>, config?: VideoTransformerConfig);
-    /**
-     * Resizes a video to specified dimensions with optional fit mode.
-     * @param fileId Unique identifier of the video file to resize.
-     * @param options Resize options including width, height, and fit mode.
-     * @returns Promise resolving to transformed video result.
-     */
-    resize(fileId: string, options: VideoResizeOptions): Promise<VideoTransformResult<TFileReturn>>;
-    /**
-     * Crops a video to the specified region.
-     * @param fileId Unique identifier of the video file to crop.
-     * @param options Crop options including region coordinates.
-     * @returns Promise resolving to transformed video result.
-     */
-    crop(fileId: string, options: VideoCropOptions): Promise<VideoTransformResult<TFileReturn>>;
-    /**
-     * Rotates a video by the specified angle.
-     * @param fileId Unique identifier of the video file to rotate.
-     * @param options Rotation configuration with angle in degrees and optional background color.
-     * @returns Promise resolving to transformed video result.
-     */
-    rotate(fileId: string, options: VideoRotateOptions): Promise<VideoTransformResult<TFileReturn>>;
-    /**
-     * Converts video format or codec.
-     * @param fileId Unique identifier of the video file to convert.
-     * @param format Target video format (e.g., "mp4", "webm", "mkv").
-     * @param options Video transformation options including quality, bitrate, and codec settings.
-     * @returns Promise resolving to transformed video result with updated format metadata.
-     */
-    convertFormat(fileId: string, format: string, options?: VideoTransformOptions): Promise<VideoTransformResult<TFileReturn>>;
-    /**
-     * Transcodes video to different codec.
-     * @param fileId Unique identifier of the video file to transcode.
-     * @param codec Target video codec (e.g., "avc", "hevc", "vp9").
-     * @param options Additional transform options.
-     * @returns Promise resolving to transformed video result.
-     */
-    transcode(fileId: string, codec: VideoTransformOptions["codec"], options?: Omit<VideoTransformOptions, "codec">): Promise<VideoTransformResult<TFileReturn>>;
-    /**
-     * Applies a custom transformation pipeline to a video.
-     * @param fileId Unique identifier of the video file to transform.
-     * @param steps Array of transformation steps to apply in sequence.
-     * @returns Promise resolving to transformed video result.
-     */
-    transform(fileId: string, steps: VideoTransformationStep[]): Promise<VideoTransformResult<TFileReturn>>;
-    /**
-     * Applies multiple transformations in sequence using Mediabunny.
-     * @param buffer The original video buffer.
-     * @param steps Array of video transformation steps to apply.
-     * @returns Promise resolving to transformed video buffer.
-     * @private
-     */
-    private applyTransformations;
-    /**
-     * Converts transformation steps to Mediabunny video options.
-     * @param steps Array of video transformation steps to convert.
-     * @returns Mediabunny video options object for conversion.
-     * @private
-     */
-    private stepsToVideoOptions;
-    /**
-     * Determines output format based on transformation steps.
-     * @param steps Array of video transformation steps.
-     * @returns Mediabunny output format instance (defaults to MP4).
-     * @private
-     */
-    private determineOutputFormat;
-    /**
-     * Converts format string to Mediabunny output format.
-     * @param format Video format string (mp4, webm, mkv, ogg).
-     * @returns Mediabunny output format instance.
-     * @private
-     */
-    private formatStringToOutputFormat;
-    /**
-     * Validates that the file is a supported video.
-     * @param file The file to validate.
-     * @returns Promise that resolves if validation passes.
-     * @throws Error if file size exceeds limits, wrong content type, unsupported format, or invalid video.
-     * @private
-     */
-    private validateVideo;
-    /**
-     * Creates transformation result with metadata.
-     * @param buffer The transformed video buffer.
-     * @param originalFile The original file information.
-     * @returns Video transformation result with metadata.
-     * @private
-     */
-    private createTransformResult;
-    /**
-     * Generates cache key for transformation.
-     * @param fileId The file identifier.
-     * @param steps Array of transformation steps.
-     * @returns Unique cache key string.
-     * @private
-     */
-    private generateCacheKey;
+  /**
+  * Creates a new VideoTransformer instance.
+  * @param storage The storage backend for retrieving and storing video files.
+  * @param config Configuration options for video transformation including cache settings, codec defaults, and size limits.
+  */
+  constructor(storage: BaseStorage<TFile, TFileReturn>, config?: VideoTransformerConfig);
+  /**
+  * Resizes a video to specified dimensions with optional fit mode.
+  * @param fileId Unique identifier of the video file to resize.
+  * @param options Resize options including width, height, and fit mode.
+  * @returns Promise resolving to transformed video result.
+  */
+  resize(fileId: string, options: VideoResizeOptions): Promise<VideoTransformResult<TFileReturn>>;
+  /**
+  * Crops a video to the specified region.
+  * @param fileId Unique identifier of the video file to crop.
+  * @param options Crop options including region coordinates.
+  * @returns Promise resolving to transformed video result.
+  */
+  crop(fileId: string, options: VideoCropOptions): Promise<VideoTransformResult<TFileReturn>>;
+  /**
+  * Rotates a video by the specified angle.
+  * @param fileId Unique identifier of the video file to rotate.
+  * @param options Rotation configuration with angle in degrees and optional background color.
+  * @returns Promise resolving to transformed video result.
+  */
+  rotate(fileId: string, options: VideoRotateOptions): Promise<VideoTransformResult<TFileReturn>>;
+  /**
+  * Converts video format or codec.
+  * @param fileId Unique identifier of the video file to convert.
+  * @param format Target video format (e.g., "mp4", "webm", "mkv").
+  * @param options Video transformation options including quality, bitrate, and codec settings.
+  * @returns Promise resolving to transformed video result with updated format metadata.
+  */
+  convertFormat(fileId: string, format: string, options?: VideoTransformOptions): Promise<VideoTransformResult<TFileReturn>>;
+  /**
+  * Transcodes video to different codec.
+  * @param fileId Unique identifier of the video file to transcode.
+  * @param codec Target video codec (e.g., "avc", "hevc", "vp9").
+  * @param options Additional transform options.
+  * @returns Promise resolving to transformed video result.
+  */
+  transcode(fileId: string, codec: VideoTransformOptions["codec"], options?: Omit<VideoTransformOptions, "codec">): Promise<VideoTransformResult<TFileReturn>>;
+  /**
+  * Applies a custom transformation pipeline to a video.
+  * @param fileId Unique identifier of the video file to transform.
+  * @param steps Array of transformation steps to apply in sequence.
+  * @returns Promise resolving to transformed video result.
+  */
+  transform(fileId: string, steps: VideoTransformationStep[]): Promise<VideoTransformResult<TFileReturn>>;
+  /**
+  * Applies multiple transformations in sequence using Mediabunny.
+  * @param buffer The original video buffer.
+  * @param steps Array of video transformation steps to apply.
+  * @returns Promise resolving to transformed video buffer.
+  * @private
+  */
+  private applyTransformations;
+  /**
+  * Converts transformation steps to Mediabunny video options.
+  * @param steps Array of video transformation steps to convert.
+  * @returns Mediabunny video options object for conversion.
+  * @private
+  */
+  private stepsToVideoOptions;
+  /**
+  * Determines output format based on transformation steps.
+  * @param steps Array of video transformation steps.
+  * @returns Mediabunny output format instance (defaults to MP4).
+  * @private
+  */
+  private determineOutputFormat;
+  /**
+  * Converts format string to Mediabunny output format.
+  * @param format Video format string (mp4, webm, mkv, ogg).
+  * @returns Mediabunny output format instance.
+  * @private
+  */
+  private formatStringToOutputFormat;
+  /**
+  * Validates that the file is a supported video.
+  * @param file The file to validate.
+  * @returns Promise that resolves if validation passes.
+  * @throws Error if file size exceeds limits, wrong content type, unsupported format, or invalid video.
+  * @private
+  */
+  private validateVideo;
+  /**
+  * Creates transformation result with metadata.
+  * @param buffer The transformed video buffer.
+  * @param originalFile The original file information.
+  * @returns Video transformation result with metadata.
+  * @private
+  */
+  private createTransformResult;
+  /**
+  * Generates cache key for transformation.
+  * @param fileId The file identifier.
+  * @param steps Array of transformation steps.
+  * @returns Unique cache key string.
+  * @private
+  */
+  private generateCacheKey;
 }
-export default VideoTransformer;
+export { VideoTransformer as default };

package/package.json

@@ -1,61 +1,61 @@
 {
   "name": "@visulima/storage",
-  "version": "1.0.0-alpha.15",
+  "version": "1.0.0-alpha.16",
   "description": "Visulima upload - Store files in a web-accessible location via a simplified API. Can automatically scale and rotate images. Includes S3, Azure, GCS and local filesystem-based backends with the most convenient features of each.",
   "keywords": [
     "anolilab",
-    "visulima",
+    "astro",
+    "aws",
+    "aws-s3",
+    "azure",
+    "better-upload",
+    "better-uploads",
+    "chunk",
+    "chunked-upload",
+    "chunked-uploads",
+    "cloudflare-r2",
+    "cloudflare-workers",
+    "digitalocean-spaces",
+    "edge-runtime",
+    "elysia",
+    "enterprise-security",
     "express",
-    "upload",
-    "uploads",
+    "fastify",
     "file",
+    "file-upload",
     "files",
-    "chunk",
-    "resumable",
-    "chunked-uploads",
-    "tus",
     "form",
-    "post",
-    "multipart",
     "form-data",
     "formdata",
-    "middleware",
-    "better-upload",
-    "better-uploads",
-    "s3",
-    "azure",
-    "aws",
+    "framework-agnostic",
     "gcs",
     "google",
-    "storage",
-    "file-upload",
-    "cloudflare-r2",
-    "digitalocean-spaces",
     "google-cloud-storage",
+    "hono",
+    "middleware",
     "minio",
-    "presigned-urls",
+    "multipart",
+    "multipart-upload",
     "nextjs",
-    "remix",
-    "sveltekit",
     "nuxt",
-    "astro",
+    "post",
+    "presigned-urls",
     "react",
-    "aws-s3",
-    "typescript",
-    "hono",
-    "fastify",
-    "elysia",
-    "framework-agnostic",
-    "edge-runtime",
-    "cloudflare-workers",
-    "vercel-edge",
+    "remix",
+    "resumable",
+    "s3",
     "serverless",
+    "storage",
+    "sveltekit",
+    "tus",
+    "typescript",
     "universal",
-    "enterprise-security",
-    "multipart-upload",
-    "chunked-upload",
+    "upload",
     "upload-library",
-    "uploadthing"
+    "uploads",
+    "uploadthing",
+    "vercel-edge",
+    "visulima"
   ],
   "homepage": "https://visulima.com/packages/uploads",
   "repository": {

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

@@ -1,91 +0,0 @@
-import { EventEmitter } from "node:events";
-import type { BaseStorage } from "../../storage/storage.d.ts";
-import type { UploadFile } from "../../storage/utils/index.d.ts";
-import type MediaTransformer from "../../transformer/media-transformer.d.ts";
-import type { ErrorResponses } from "../../utils/errors.d.ts";
-import type { ResponseBodyType } from "../../utils/types.d.ts";
-import type { UploadOptions } from "../types.d.ts";
-/**
- * Core base class containing shared business logic for all handlers.
- * This class is platform-agnostic and contains no Node.js or Web API specific code.
- * @template TFile The file type used by this handler.
- */
-declare abstract class BaseHandlerCore<TFile extends UploadFile> extends EventEmitter {
-    /**
-     * Response body type for the handler.
-     */
-    responseType: ResponseBodyType;
-    /**
-     * Storage instance for file operations.
-     */
-    storage: BaseStorage<TFile>;
-    /**
-     * Optional media transformer for image/video processing.
-     */
-    mediaTransformer?: MediaTransformer;
-    /**
-     * Whether to disable termination for finished uploads.
-     */
-    disableTerminationForFinishedUploads?: boolean;
-    /**
-     * Logger instance for debugging and error reporting.
-     */
-    protected logger?: Console;
-    /**
-     * Gets the logger instance.
-     * @returns Logger instance or undefined.
-     */
-    get loggerInstance(): Console | undefined;
-    /**
-     * Internal error responses configuration.
-     */
-    protected internalErrorResponses: ErrorResponses;
-    /**
-     * Gets the error responses configuration.
-     * @returns Error responses configuration.
-     */
-    get errorResponses(): ErrorResponses;
-    constructor({ disableTerminationForFinishedUploads, mediaTransformer, storage }: UploadOptions<TFile>);
-    /**
-     * Sets custom error responses.
-     * @param value Partial error responses to override defaults.
-     */
-    set errorResponses(value: Partial<ErrorResponses>);
-    /**
-     * Assemble error responses by merging defaults with custom overrides.
-     * @param customErrors Custom error responses to override defaults
-     */
-    assembleErrors: (customErrors?: {}) => void;
-    /**
-     * Parses HTTP Range header and returns start/end byte positions for partial content requests.
-     * @param rangeHeader HTTP Range header value (e.g., "bytes=0-1023").
-     * @param fileSize Total size of the file in bytes.
-     * @returns Object with start and end positions, or undefined if range is invalid.
-     */
-    parseRangeHeader(rangeHeader: string | undefined, fileSize: number): {
-        end: number;
-        start: number;
-    } | undefined;
-    /**
-     * Build file URL from request and file data.
-     * Platform-agnostic version that accepts URL string.
-     * @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 buildFileUrlFromString(requestUrl: string, file: TFile): string;
-    /**
-     * Negotiates content type based on Accept header and supported formats.
-     * Platform-agnostic version that accepts header string.
-     * @param acceptHeader Accept header value
-     * @param supportedTypes Array of supported MIME types to match against
-     * @returns Best matching content type or undefined if no match found
-     */
-    negotiateContentTypeFromHeader(acceptHeader: string | undefined, supportedTypes: string[]): string | undefined;
-    /**
-     * Check for undefined ID or path errors and throw appropriate HTTP errors.
-     * @param error The error to check
-     */
-    protected checkForUndefinedIdOrPath(error: unknown): void;
-}
-export default BaseHandlerCore;

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

@@ -1,76 +0,0 @@
-import type { UploadFile } from "../../storage/utils/index.d.ts";
-import type { UploadResponse } from "../../utils/types.d.ts";
-import type { Handlers, ResponseFile, ResponseList, UploadOptions } from "../types.d.ts";
-import BaseHandlerCore from "./base-handler-core.d.ts";
-/**
- * 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;
-}
-export default BaseHandlerFetch;