@visulima/storage 1.0.0-alpha.9 → 1.0.1

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

@@ -1,152 +0,0 @@
-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

@@ -1,72 +0,0 @@
-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

@@ -1,78 +0,0 @@
-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;
-}

package/dist/handler/types.d.ts

@@ -1,53 +0,0 @@
-import type { EventEmitter } from "node:events";
-import type { IncomingMessage } from "node:http";
-import type { Readable } from "node:stream";
-import type { PaginationResult } from "@visulima/pagination";
-import type { BaseStorage } from "../storage/storage.d.ts";
-import type { UploadEventType, UploadFile } from "../storage/utils/index.d.ts";
-import type MediaTransformer from "../transformer/media-transformer.d.ts";
-import type { UploadError } from "../utils/errors.d.ts";
-type WebRequest = globalThis.Request;
-type WebResponse = globalThis.Response;
-interface BaseResponse {
-    headers: Record<string, number | string>;
-    statusCode: number;
-}
-export interface StreamingResponse extends BaseResponse {
-    /** Total size of the stream (for Content-Length header) */
-    size?: number;
-    /** Stream of data to send */
-    stream: Readable;
-}
-export interface RequestEvent {
-    request: Pick<IncomingMessage, "headers" | "method" | "url">;
-}
-export type AsyncHandler<Request, Response> = (request: Request, response: Response) => Promise<void | ResponseFile<UploadFile> | ResponseList<UploadFile> | StreamingResponse>;
-export type Handlers = "delete" | "download" | "get" | "head" | "options" | "patch" | "post" | "put";
-export type MethodHandler<Request, Response> = {
-    [h in Handlers]?: AsyncHandler<Request, Response>;
-};
-export type UploadEvent<TFile extends UploadFile> = RequestEvent & TFile;
-export type UploadErrorEvent = RequestEvent & UploadError;
-export type ResponseFile<TFile extends UploadFile> = BaseResponse & TFile & {
-    /** Optional stream for streaming responses instead of content buffer */
-    stream?: Readable;
-};
-export type ResponseList<TFile extends UploadFile> = BaseResponse & {
-    data: PaginationResult<TFile> | TFile[];
-};
-export interface BaseHandler<TFile extends UploadFile> extends EventEmitter {
-    emit: ((event: "error", error: UploadErrorEvent) => boolean) & ((event: UploadEventType, payload: UploadEvent<TFile>) => boolean);
-    fetch: (request: WebRequest) => Promise<WebResponse>;
-    off: ((event: "error", listener: (error: UploadErrorEvent) => void) => this) & ((event: UploadEventType, listener: (payload: UploadEvent<TFile>) => void) => this);
-    on: ((event: "error", listener: (error: UploadErrorEvent) => void) => this) & ((event: UploadEventType, listener: (payload: UploadEvent<TFile>) => void) => this);
-}
-export interface UploadOptions<TFile extends UploadFile> {
-    disableTerminationForFinishedUploads?: boolean;
-    /** Maximum file size for multipart parser (default: min(storage.maxUploadSize, 1GB)) */
-    maxFileSize?: number;
-    /** Maximum header size for multipart parser (default: 64KB) */
-    maxHeaderSize?: number;
-    mediaTransformer?: MediaTransformer;
-    storage: BaseStorage<TFile>;
-}
-export {};

package/dist/handler/utils/request-parser.d.ts

@@ -1,72 +0,0 @@
-import type { IncomingMessage } from "node:http";
-import type { FileInit } from "../../storage/utils/index.d.ts";
-/**
- * Parses metadata from X-File-Metadata header.
- * @param request The HTTP request
- * @param existingMetadata Existing metadata to merge with (optional)
- * @returns Parsed metadata object
- */
-export declare const parseMetadata: (request: IncomingMessage, existingMetadata?: Record<string, unknown>) => Record<string, unknown>;
-/**
- * Parses filename from Content-Disposition header value string.
- * Uses a safer parsing approach to avoid ReDoS vulnerabilities.
- * @param contentDisposition The Content-Disposition header value
- * @returns Filename if found, undefined otherwise
- */
-export declare const parseContentDispositionValue: (contentDisposition: string | null | undefined) => string | undefined;
-/**
- * Parses filename from Content-Disposition header.
- * Uses a safer parsing approach to avoid ReDoS vulnerabilities.
- * @param request The HTTP request
- * @returns Filename if found, undefined otherwise
- */
-export declare const parseContentDisposition: (request: IncomingMessage) => string | undefined;
-/**
- * Parses chunked upload headers (X-Chunk-Offset, X-Total-Size, etc.).
- * @param request The HTTP request
- * @returns Object with chunk offset, total size, and chunked upload flag
- */
-export declare const parseChunkHeaders: (request: IncomingMessage) => {
-    chunkOffset?: number;
-    isChunkedUpload: boolean;
-    totalSize?: number;
-};
-/**
- * Validates that a request has a body.
- * @param request The HTTP request
- * @param allowEmptyForChunked Whether to allow empty body for chunked uploads
- * @throws {HttpError} If body is required but missing
- */
-export declare const validateRequestBody: (request: IncomingMessage, allowEmptyForChunked?: boolean) => void;
-/**
- * Validates Content-Length header.
- * @param request The HTTP request
- * @param allowZeroForChunked Whether to allow zero length for chunked uploads
- * @param maxSize Maximum allowed size
- * @returns Parsed content length
- * @throws {HttpError} If Content-Length is invalid or exceeds max size
- */
-export declare const validateContentLength: (request: IncomingMessage, allowZeroForChunked?: boolean, maxSize?: number) => number;
-/**
- * Extracts file initialization config from request headers.
- * @param request The HTTP request
- * @param contentLength The content length (already validated)
- * @param contentType The content type (default: application/octet-stream)
- * @returns FileInit configuration object
- */
-export declare const extractFileInit: (request: IncomingMessage, contentLength: number, contentType?: string) => FileInit;
-/**
- * Validates chunk offset and size for chunked uploads.
- * @param chunkOffset The chunk offset
- * @param contentLength The chunk content length
- * @param totalSize The total file size
- * @throws {HttpError} If validation fails
- */
-export declare const validateChunk: (chunkOffset: number, contentLength: number, totalSize: number) => void;
-/**
- * Gets content type from request headers with fallback.
- * @param request The HTTP request
- * @param fallback Default content type if not found (default: application/octet-stream)
- * @returns Content type string
- */
-export declare const getContentType: (request: IncomingMessage, fallback?: string) => string;

package/dist/handler/utils/response-builder.d.ts

@@ -1,83 +0,0 @@
-import type { UploadFile } from "../../storage/utils/index.d.ts";
-import type { Header } from "../../utils/types.d.ts";
-import type { ResponseFile } from "../types.d.ts";
-/**
- * Builds a standard ResponseFile from a file object and headers.
- * @param file The file object to convert to a response
- * @param headers Additional headers to include
- * @param statusCode HTTP status code (default: 200)
- * @returns ResponseFile with file data and headers
- */
-export declare const buildResponseFile: <TFile extends UploadFile>(file: TFile, headers?: Record<string, string | number>, statusCode?: number) => ResponseFile<TFile>;
-/**
- * Builds standard file headers including Location, expiration, and ETag.
- * @param file The file object
- * @param locationUrl The Location header URL
- * @param additionalHeaders Additional headers to merge in
- * @returns Headers object with standard file headers
- */
-export declare const buildFileHeaders: <TFile extends UploadFile>(file: TFile, locationUrl: string, additionalHeaders?: Record<string, string | number>) => Record<string, string | number>;
-/**
- * Builds chunked upload headers for progress tracking.
- * @param file The file object with chunked upload metadata
- * @param isComplete Whether the upload is complete
- * @returns Headers object with chunked upload progress headers
- */
-export declare const buildChunkedUploadHeaders: <TFile extends UploadFile>(file: TFile, isComplete: boolean) => Record<string, string | number>;
-/**
- * Builds a Location header URL for a file.
- * @param requestUrl The request URL or originalUrl
- * @param fileId The file ID
- * @param contentType The file content type (for extension)
- * @param useRelativeLocation Whether to use relative URLs
- * @param baseUrl The base URL (for absolute URLs)
- * @returns Location URL string
- */
-export declare const buildLocationHeader: (requestUrl: string | undefined, fileId: string, contentType: string, useRelativeLocation: boolean, baseUrl?: string) => string;
-/**
- * Builds standard file metadata headers for HEAD requests.
- * @param file The file object
- * @returns Headers object with file metadata
- */
-export declare const buildFileMetadataHeaders: <TFile extends UploadFile>(file: TFile) => Record<string, string | number>;
-/**
- * Converts headers from Record format to string format, handling arrays.
- * @param headers Headers object that may contain arrays
- * @returns Headers object with all values as strings
- */
-export declare const convertHeadersToString: (headers: Record<string, Header>) => Record<string, string>;
-/**
- * Builds an error response body in standard format.
- * @param error The error object
- * @returns Error response body object
- */
-export declare const buildErrorResponseBody: (error: {
-    code?: string;
-    message?: string;
-    name?: string;
-}) => {
-    error: {
-        code: string;
-        message: string;
-        name: string;
-    };
-};
-/**
- * Prepares response body and headers for sending, handling different body types.
- * @param body The response body (string, Buffer, or object)
- * @param headers Existing headers
- * @returns Object with prepared data and headers
- */
-export declare const prepareResponseBody: (body: string | Buffer | object | undefined, headers?: Record<string, string | number>) => {
-    data: Buffer | string;
-    headers: Record<string, string | number>;
-};
-/**
- * Cleans file data for serialization by removing non-serializable properties.
- * @param fileData File data object
- * @returns Cleaned file data object
- */
-export declare const cleanFileData: <TFile extends UploadFile>(fileData: TFile & {
-    content?: unknown;
-    stream?: unknown;
-}) => Omit<TFile, "content" | "stream">;

package/dist/handler/utils/storage-utils.d.ts

@@ -1,10 +0,0 @@
-/**
- * Wait for storage to be ready before handling requests.
- * This ensures storage initialization (e.g., AWS S3, GCS) completes before processing uploads.
- * @param storage Storage instance with isReady property
- * @param timeoutMs Maximum time to wait in milliseconds (default: 5000)
- * @throws Error if storage doesn't become ready within timeout
- */
-export declare const waitForStorage: (storage: {
-    isReady: boolean;
-}, timeoutMs?: number) => Promise<void>;

package/dist/handler/utils/stream-utils.d.ts

@@ -1,29 +0,0 @@
-import type { ServerResponse } from "node:http";
-import type { Readable } from "node:stream";
-/**
- * Creates a range-limited stream that properly handles backpressure.
- * @param sourceStream Source readable stream to limit
- * @param start Start byte position (inclusive)
- * @param end End byte position (inclusive)
- * @returns New readable stream limited to the specified byte range
- */
-export declare const createRangeLimitedStream: (sourceStream: Readable, start: number, end: number) => Readable;
-/**
- * Pipes streams with proper backpressure handling and error management.
- * @param source Source readable stream to pipe from
- * @param destination Destination response stream to pipe to
- * @param sendError Function to send error responses
- */
-export declare const pipeWithBackpressure: <TResponse extends ServerResponse>(source: Readable, destination: TResponse, sendError: (response: TResponse, error: Error) => Promise<void>) => void;
-/**
- * Creates a stream response configuration object.
- * @param stream The readable stream
- * @param size Optional total size of the stream
- * @param headers Optional headers to include
- * @returns Stream response configuration
- */
-export declare const createStreamResponse: (stream: Readable, size?: number, headers?: Record<string, string | number>) => {
-    headers: Record<string, string | number>;
-    size?: number;
-    stream: Readable;
-};

package/dist/handler/utils/upload-handlers.d.ts

@@ -1,76 +0,0 @@
-import type { IncomingMessage, ServerResponse } from "node:http";
-import type { Readable } from "node:stream";
-import type { UploadFile } from "../../storage/utils/index.d.ts";
-import type { ResponseBody, UploadResponse } from "../../utils/types.d.ts";
-import type { ResponseFile, ResponseList } from "../types.d.ts";
-/**
- * Handles HEAD/OPTIONS requests.
- * @param file Response file with headers and status code
- * @param send Function to send response
- */
-export declare const handleHeadOptionsRequest: <TFile extends UploadFile, NodeResponse extends ServerResponse>(file: ResponseFile<TFile>, send: (response: NodeResponse, data: {
-    headers: Record<string, string | number>;
-    statusCode: number;
-}) => void, response: NodeResponse) => void;
-/**
- * Handles GET requests with streaming support.
- * @param file Response file (may contain stream)
- * @param request HTTP request
- * @param response HTTP response
- * @param next Optional Express next function
- * @param send Function to send regular response
- * @param sendStream Function to send stream response
- * @param parseRangeHeader Function to parse range header
- */
-export declare const handleGetRequest: <TFile extends UploadFile, NodeResponse extends ServerResponse>(file: ResponseFile<TFile> | ResponseList<TFile>, request: IncomingMessage, response: NodeResponse, next: (() => void) | undefined, send: (response: NodeResponse, data: UploadResponse<ResponseBody>) => void, sendStream: (response: NodeResponse, stream: Readable, options: {
-    headers: Record<string, string | number>;
-    range?: {
-        end: number;
-        start: number;
-    };
-    size?: number;
-    statusCode: number;
-}) => void, parseRangeHeader: (rangeHeader: string | undefined, fileSize: number) => {
-    end: number;
-    start: number;
-} | undefined) => void;
-/**
- * Handles completed upload responses.
- * @param file Response file
- * @param request HTTP request
- * @param response HTTP response
- * @param next Optional Express next function
- * @param storage Storage instance for onComplete hook
- * @param logger Optional logger
- * @param finish Function to finish the response
- */
-export declare const handleCompletedUpload: <TFile extends UploadFile, NodeResponse extends ServerResponse>(file: ResponseFile<TFile>, request: IncomingMessage, response: NodeResponse, next: (() => void) | undefined, storage: {
-    onComplete: (file: TFile, responseFile: ResponseFile<TFile>, request?: IncomingMessage) => void | Promise<void>;
-}, logger: {
-    error?: (message: string, error: unknown) => void;
-} | undefined, finish: (request: IncomingMessage, response: NodeResponse, uploadResponse: ResponseFile<TFile>) => void) => Promise<void>;
-/**
- * Handles partial upload responses.
- * @param file Response file
- * @param request HTTP request
- * @param response HTTP response
- * @param send Function to send response
- */
-export declare const handlePartialUpload: <TFile extends UploadFile, NodeResponse extends ServerResponse>(file: ResponseFile<TFile>, request: IncomingMessage, response: NodeResponse, send: (response: NodeResponse, data: {
-    body: Buffer | string | undefined;
-    headers: Record<string, string>;
-    statusCode: number;
-}) => void) => void;
-/**
- * Handles errors during upload processing.
- * @param error The error that occurred
- * @param request HTTP request
- * @param emit Function to emit events
- * @param listenerCount Function to count event listeners
- * @param logger Optional logger
- * @param sendError Function to send error response
- * @param response HTTP response
- */
-export declare const handleUploadError: <NodeResponse extends ServerResponse>(error: unknown, request: IncomingMessage, emit: (event: string, data: unknown) => boolean, listenerCount: (event: string) => number, logger: {
-    error?: (message: string, error: unknown) => void;
-} | undefined, sendError: (response: NodeResponse, error: Error) => Promise<void>, response: NodeResponse) => Promise<void>;

package/dist/metrics/index.d.ts

@@ -1,2 +0,0 @@
-export { default as NoOpMetrics } from "./no-op-metrics.d.ts";
-export { default as OpenTelemetryMetrics } from "./opentelemetry-metrics.d.ts";

package/dist/metrics/no-op-metrics.d.ts

@@ -1,15 +0,0 @@
-/**
- * No-op metrics implementation.
- * Used when metrics are not provided, ensuring no overhead when metrics are disabled.
- */
-import type { Metrics } from "../utils/types.d.ts";
-/**
- * No-op metrics that does nothing.
- * Used as a default when metrics are not provided.
- */
-declare class NoOpMetrics implements Metrics {
-    increment(_name: string, _value?: number, _attributes?: Record<string, string | number>): void;
-    timing(_name: string, _duration: number, _attributes?: Record<string, string | number>): void;
-    gauge(_name: string, _value: number, _attributes?: Record<string, string | number>): void;
-}
-export default NoOpMetrics;