@visulima/storage 1.0.0-alpha.8 → 1.0.0

package/dist/transformer/validation-error.d.ts

@@ -1,23 +0,0 @@
-/**
- * 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 default ValidationError;

package/dist/utils/cache.d.ts

@@ -1,32 +0,0 @@
-/**
- * Simple cache interface that any cache implementation can follow
- */
-export interface Cache<K = string, V = unknown> {
-    /** Clear all cache entries */
-    clear: () => void | Promise<void>;
-    /** Delete a value from cache */
-    delete: (key: K) => boolean | Promise<boolean>;
-    /** Get a value from cache */
-    get: (key: K) => V | undefined | Promise<V | undefined>;
-    /** Check if a key exists in cache */
-    has: (key: K) => boolean | Promise<boolean>;
-    /** Set a value in cache */
-    set: (key: K, value: V, options?: CacheOptions) => boolean | Promise<boolean>;
-}
-/**
- * Options for cache operations
- */
-export interface CacheOptions {
-    /** TTL in milliseconds */
-    ttl?: number;
-}
-/**
- * No-op cache implementation that does nothing (used when caching is disabled)
- */
-export declare class NoOpCache<K = string, V = unknown> implements Cache<K, V> {
-    get(): undefined;
-    set(): boolean;
-    delete(): boolean;
-    clear(): void;
-    has(): boolean;
-}

package/dist/utils/chunked-upload.d.ts

@@ -1,65 +0,0 @@
-import type { UploadFile } from "../storage/utils/index.d.ts";
-/**
- * Chunk information structure for tracking uploaded chunks.
- */
-export interface ChunkInfo {
-    /** Optional checksum for validation */
-    checksum?: string;
-    /** Length of chunk in bytes */
-    length: number;
-    /** Byte offset where chunk starts */
-    offset: number;
-}
-/**
- * Checks if upload is complete based on chunks coverage.
- * Verifies that all chunks form a continuous sequence covering the total file size.
- * @param chunks Array of chunk information objects
- * @param totalSize Total expected file size in bytes
- * @returns True if upload is complete, false otherwise
- */
-export declare const isUploadComplete: (chunks: ChunkInfo[], totalSize: number) => boolean;
-/**
- * Validates a chunk against file constraints.
- * @param chunkOffset Byte offset where chunk starts
- * @param chunkLength Length of chunk in bytes
- * @param totalSize Total file size in bytes
- * @param maxChunkSize Maximum allowed chunk size (optional)
- * @throws {Error} If validation fails
- */
-export declare const validateChunk: (chunkOffset: number, chunkLength: number, totalSize: number, maxChunkSize?: number) => void;
-/**
- * Tracks a chunk in the metadata chunks array (idempotent).
- * @param chunks Existing chunks array
- * @param chunkInfo New chunk information to track
- * @returns Updated chunks array
- */
-export declare const trackChunk: (chunks: ChunkInfo[], chunkInfo: ChunkInfo) => ChunkInfo[];
-/**
- * Calculates upload progress based on chunks.
- * @param chunks Array of chunk information objects
- * @param totalSize Total expected file size in bytes
- * @returns Object with bytesWritten and completion percentage
- */
-export declare const calculateUploadProgress: (chunks: ChunkInfo[], totalSize: number) => {
-    bytesWritten: number;
-    percentage: number;
-};
-/**
- * Gets the total bytes written based on file metadata.
- * For chunked uploads, uses bytesWritten from file or calculates from chunks.
- * @param file The file object
- * @returns Total bytes written
- */
-export declare const getBytesWritten: <TFile extends UploadFile>(file: TFile) => number;
-/**
- * Checks if a file is a chunked upload based on metadata.
- * @param file The file object
- * @returns True if file is a chunked upload
- */
-export declare const isChunkedUpload: <TFile extends UploadFile>(file: TFile) => boolean;
-/**
- * Gets the total size for a chunked upload.
- * @param file The file object
- * @returns Total size or undefined if not a chunked upload
- */
-export declare const getTotalSize: <TFile extends UploadFile>(file: TFile) => number | undefined;

package/dist/utils/detect-file-type.d.ts

@@ -1,28 +0,0 @@
-import type { Readable } from "node:stream";
-/**
- * Detects the file type from a buffer using magic numbers (binary signatures).
- * This provides more accurate file type detection than relying on file extensions or Content-Type headers.
- * @param buffer The buffer to detect file type from
- * @returns The detected file type with extension and MIME type, or undefined if detection fails
- */
-export declare const detectFileTypeFromBuffer: (buffer: Buffer | Uint8Array) => Promise<{
-    ext: string;
-    mime: string;
-} | undefined>;
-/**
- * Detects file type from a Node.js stream by peeking at the first chunk and returns both the detected type and a new stream.
- * This peeks at the stream data without consuming it, allowing the original stream to be used normally.
- * @param stream The readable stream to detect file type from
- * @param options Optional configuration for file type detection
- * @param options.sampleSize The sample size in bytes to peek (default: 4100)
- * @returns An object with the detected file type and a new readable stream
- */
-export declare const detectFileTypeFromStream: (stream: Readable, options?: {
-    sampleSize?: number;
-}) => Promise<{
-    fileType?: {
-        ext: string;
-        mime: string;
-    };
-    stream: Readable;
-}>;

package/dist/utils/errors.d.ts

@@ -1,74 +0,0 @@
-import type { HttpError } from "./types.d.ts";
-/**
- * Canonical error codes used across handlers and storage adapters.
- * These codes map to standardized HTTP status codes and error messages.
- */
-export declare enum ERRORS {
-    BAD_REQUEST = "BadRequest",
-    CHECKSUM_MISMATCH = "ChecksumMismatch",
-    FILE_CONFLICT = "FileConflict",
-    FILE_ERROR = "FileError",
-    FILE_LOCKED = "FileLocked",
-    FILE_NOT_ALLOWED = "FileNotAllowed",
-    FILE_NOT_FOUND = "FileNotFound",
-    FORBIDDEN = "Forbidden",
-    GONE = "Gone",
-    INVALID_FILE_NAME = "InvalidFileName",
-    INVALID_FILE_SIZE = "InvalidFileSize",
-    INVALID_RANGE = "InvalidRange",
-    INVALID_TYPE = "Invalidtype",
-    METHOD_NOT_ALLOWED = "MethodNotAllowed",
-    REQUEST_ABORTED = "RequestAborted",
-    REQUEST_ENTITY_TOO_LARGE = "RequestEntityTooLarge",
-    STORAGE_BUSY = "StorageBusy",
-    STORAGE_ERROR = "StorageError",
-    TOO_MANY_REQUESTS = "TooManyRequests",
-    UNKNOWN_ERROR = "UnknownError",
-    UNPROCESSABLE_ENTITY = "UnprocessableEntity",
-    UNSUPPORTED_CHECKSUM_ALGORITHM = "UnsupportedChecksumAlgorithm",
-    UNSUPPORTED_MEDIA_TYPE = "UnsupportedMediaType"
-}
-/**
- * Type mapping of error codes to standardized HTTP error responses.
- * @template T - The error code type (defaults to string)
- */
-export type ErrorResponses<T extends string = string> = {
-    [K in T]: HttpError;
-};
-/**
- * Mapping of error codes to HttpError response objects.
- * @returns Map of error codes to standardized HTTP error responses
- */
-export declare const ErrorMap: ErrorResponses<ERRORS>;
-/**
- * Error subclass carrying a stable error code and optional detail.
- * Provides structured error information for upload operations.
- */
-export declare class UploadError extends Error {
-    name: string;
-    /** The standardized error code from the ERRORS enum */
-    UploadErrorCode: ERRORS;
-    /** Optional additional error details */
-    detail?: unknown;
-    /**
-     * Creates a new UploadError instance.
-     * @param code Standardized error code (defaults to UNKNOWN_ERROR)
-     * @param message Human-readable error message (defaults to the code)
-     * @param detail Optional additional error details
-     */
-    constructor(code?: ERRORS, message?: string, detail?: unknown);
-}
-/**
- * Type guard to check if an error is an UploadError instance.
- * @param error Error to check
- * @returns True if the error is an UploadError with a valid error code
- */
-export declare const isUploadError: (error: unknown) => error is UploadError;
-/**
- * Convenience function to throw an UploadError from a string error code.
- * Looks up the appropriate error message from ErrorMap.
- * @param UploadErrorCode String error code to convert to UploadError
- * @param detail Optional additional error details
- * @throws UploadError with the specified code and message
- */
-export declare const throwErrorCode: (UploadErrorCode: ERRORS | string, detail?: string) => never;

package/dist/utils/file-path-url-matcher.d.ts

@@ -1,18 +0,0 @@
-declare const filePathUrlMatcher: (path: string) => {
-    params: PathMatch;
-    path: string;
-} | undefined;
-/**
- * Parsed URL components from file path matching.
- */
-export type PathMatch = {
-    /** File extension (e.g., "jpg", "png") */
-    ext?: string;
-    /** Metadata request type (e.g., "metadata") */
-    metadata?: string;
-    /** Path segments before the UUID */
-    path?: string[];
-    /** File UUID identifier */
-    uuid: string;
-};
-export default filePathUrlMatcher;

package/dist/utils/headers.d.ts

@@ -1,111 +0,0 @@
-/**
- * Enhanced HTTP header utilities using remix-run/headers for type-safe header manipulation.
- * This module provides internal utilities for the storage package to handle complex headers.
- */
-import { Accept, ContentDisposition, ContentType } from "@remix-run/headers";
-import type { Headers as UploadHeaders } from "./types.d.ts";
-/**
- * Cache-Control directive options
- */
-export interface CacheControlOptions {
-    immutable?: boolean;
-    maxAge?: number;
-    minFresh?: number;
-    mustRevalidate?: boolean;
-    noCache?: boolean;
-    noStore?: boolean;
-    private?: boolean;
-    proxyRevalidate?: boolean;
-    public?: boolean;
-    sMaxAge?: number;
-    staleIfError?: number;
-    staleWhileRevalidate?: number;
-}
-/**
- * Utility functions for working with HTTP headers using \@remix-run/headers.
- */
-export declare const HeaderUtilities: {
-    /**
-     * Check if client accepts a specific media type based on Accept header.
-     * @param acceptHeader HTTP Accept header value
-     * @param mediaType Media type to check for acceptance
-     * @returns True if the media type is accepted by the client
-     */
-    acceptsMediaType(acceptHeader: string | undefined, mediaType: string): boolean;
-    /**
-     * Create Cache-Control header value from options.
-     * @param options Cache control directives configuration
-     * @returns Cache-Control header value string
-     */
-    createCacheControl(options: CacheControlOptions): string;
-    /**
-     * Create common cache control presets with predefined configurations.
-     * @param preset Preset name ('no-cache', 'no-store', 'public', 'private', or 'immutable')
-     * @returns Cache-Control header value string for the preset
-     */
-    createCacheControlPreset(preset: "no-cache" | "no-store" | "public" | "private" | "immutable"): string;
-    /**
-     * Create Content-Disposition header for file downloads with optional filename.
-     * @param options
-     * @param options.filename Filename for the download
-     * @param options.filenameSplat Alternative filename format
-     * @param options.type Disposition type ('inline' or 'attachment')
-     * @returns Content-Disposition header value string
-     */
-    createContentDisposition(options: {
-        filename?: string;
-        filenameSplat?: string;
-        type: "inline" | "attachment";
-    }): string;
-    /**
-     * Create Content-Type header value from structured data with optional charset and boundary.
-     * @param options
-     * @param options.boundary Multipart boundary string
-     * @param options.charset Character encoding (e.g., 'utf8')
-     * @param options.mediaType MIME media type (e.g., 'application/json')
-     * @returns Content-Type header value string
-     */
-    createContentType(options: {
-        boundary?: string;
-        charset?: string;
-        mediaType: string;
-    }): string;
-    /**
-     * Get content type with charset if not already present.
-     * @param contentType Content-Type header value to ensure charset for
-     * @param defaultCharset Default charset to use if not present (default: 'utf8')
-     * @returns Content-Type header value with charset ensured
-     */
-    ensureCharset(contentType: string, defaultCharset?: string): string;
-    /**
-     * Convert our Headers type to native Headers object.
-     * @param headers Headers in array or object format
-     * @returns Headers instance with converted header values
-     */
-    fromHeaders(headers: UploadHeaders): Headers;
-    /**
-     * Get preferred media type from Accept header based on quality factors and supported types.
-     * @param acceptHeader HTTP Accept header value
-     * @param supportedTypes Array of supported MIME types to match against
-     * @returns Best matching media type or undefined if no match found
-     */
-    getPreferredMediaType(acceptHeader: string | undefined, supportedTypes: string[]): string | undefined;
-    /**
-     * Parse Accept header with quality factor support.
-     * @param headerValue HTTP Accept header value to parse
-     * @returns Accept instance or undefined if header is invalid or missing
-     */
-    parseAccept(headerValue: string | undefined): Accept | undefined;
-    /**
-     * Parse Content-Disposition header into structured object.
-     * @param headerValue HTTP Content-Disposition header value to parse
-     * @returns ContentDisposition instance or undefined if header is invalid or missing
-     */
-    parseContentDisposition(headerValue: string | undefined): ContentDisposition | undefined;
-    /**
-     * Parse Content-Type header with structured access to media type, charset, and boundary.
-     * @param headerValue HTTP Content-Type header value to parse
-     * @returns ContentType instance or undefined if header is invalid or missing
-     */
-    parseContentType(headerValue: string | undefined): ContentType | undefined;
-};

package/dist/utils/http.d.ts

@@ -1,92 +0,0 @@
-import type { IncomingMessage, OutgoingHttpHeader, ServerResponse } from "node:http";
-import { Readable } from "node:stream";
-import type { Headers, IncomingMessageWithBody } from "./types.d.ts";
-/**
- * Reads the body of an HTTP request as a string with optional size limit.
- * @param request HTTP request object to read body from
- * @param encoding Text encoding to use (defaults to 'utf8')
- * @param limit Maximum body size in characters (throws error if exceeded)
- * @returns Promise resolving to the request body as a string
- */
-export declare const readBody: (request: IncomingMessage, encoding: BufferEncoding, limit: number | undefined) => Promise<string>;
-/**
- * Retrieve the value of a specific header of an HTTP request.
- * @param request request object
- * @param name name of the header
- * @param all if true, returns  all values of the header, comma-separated, otherwise returns the last value.
- */
-/**
- * Get a header value. If `all` is true, returns the comma-joined value.
- */
-export declare const getHeader: (request: IncomingMessage, name: string, all?: boolean) => string;
-/**
- * Extracts JSON metadata from an HTTP request body.
- * Parses the request body as JSON if the content type is 'application/json'.
- * @param request HTTP request with potential body data
- * @param limit Maximum body size limit in bytes (default: 16MB)
- * @returns Parsed metadata object, or empty object if not JSON
- */
-export declare const getMetadata: (request: IncomingMessageWithBody<Record<string, unknown>>, limit?: number) => Promise<Record<string, unknown>>;
-/**
- * Appends value to the end of the multi-value header
- */
-/** Append a value to a multi-valued response header. */
-export declare const appendHeader: (response: ServerResponse, name: string, value: OutgoingHttpHeader) => void;
-/**
- * Sets the value of a specific header of an HTTP response.
- */
-/** Set multiple response headers and expose them for CORS. */
-export declare const setHeaders: (response: ServerResponse, headers?: Headers) => void;
-/**
- * Extracts host with port from a HTTP or HTTPS request.
- * Prefers x-forwarded-host header for proxy compatibility.
- * @param request HTTP request object
- * @returns Host string with port (e.g., "example.com:8080")
- */
-export declare const extractHost: (request: IncomingMessage & {
-    host?: string;
-    hostname?: string;
-}) => string;
-/**
- * Extracts protocol from a HTTP or HTTPS request.
- * Prefers x-forwarded-proto header for proxy compatibility.
- * @param request HTTP request object
- * @returns Protocol string ('http' or 'https')
- */
-export declare const extractProto: (request: IncomingMessage) => string;
-/**
- * Try build a protocol:hostname:port string from a request object.
- */
-/** Build protocol://host from an IncomingMessage using forwarded headers. */
-export declare const getBaseUrl: (request: IncomingMessage) => string;
-/**
- * Extracts the real path from a request URL, excluding query parameters.
- * Prefers originalUrl for Express compatibility.
- * @internal
- * @param request HTTP request object
- * @returns The path component of the URL without query parameters
- * @throws TypeError if path is undefined
- */
-export declare const getRealPath: (request: IncomingMessage & {
-    originalUrl?: string;
-}) => string;
-/**
- * @internal
- */
-export declare const uuidRegex: RegExp;
-/**
- * Extracts a UUID identifier from the request URL path.
- * Uses regex pattern to match UUID-like strings in the URL.
- * @internal
- * @param request HTTP request object
- * @returns The extracted UUID identifier
- * @throws TypeError if no valid ID is found in the path
- */
-export declare const getIdFromRequest: (request: IncomingMessage & {
-    originalUrl?: string;
-}) => string;
-/**
- * Converts a request to a Node.js Readable stream.
- * Handles both Node.js IncomingMessage and Web API Request objects.
- */
-export declare const getRequestStream: (request: IncomingMessage | Request) => Readable;

package/dist/utils/locker.d.ts

@@ -1,26 +0,0 @@
-import { LRUCache as Cache } from "lru-cache";
-/**
- * A simple lock map keyed by strings, backed by LRUCache. Locks
- * automatically expire according to the configured TTL preventing deadlocks.
- */
-declare class Locker<K extends string = string, V extends string = string> extends Cache<K, V, number> {
-    /**
-     * Creates a new Locker instance with configurable TTL and cache options.
-     * @param options LRU cache configuration options
-     */
-    constructor(options?: Cache.Options<K, V, number>);
-    /**
-     * Acquires a lock for the specified key.
-     * Throws an error if the key is already locked.
-     * @param key The key to lock
-     * @returns The lock token (same as the key)
-     * @throws Error if the key is already locked
-     */
-    lock(key: K): string;
-    /**
-     * Releases the lock for the specified key.
-     * @param key The key to unlock
-     */
-    unlock(key: K): void;
-}
-export default Locker;

package/dist/utils/pipes/stream-checksum.d.ts

@@ -1,47 +0,0 @@
-import type { BinaryToTextEncoding } from "node:crypto";
-import { PassThrough, Transform } from "node:stream";
-/**
- * Transform stream that validates checksums as data passes through.
- * Calculates hash of streaming data and validates against expected checksum.
- */
-export declare class StreamChecksum extends Transform {
-    readonly checksum: string;
-    readonly algorithm: string;
-    private readonly encoding;
-    length: number;
-    private digest;
-    private hash;
-    /**
-     * Gets the calculated digest value after the stream has finished processing.
-     * @returns The digest value in the configured encoding, or empty string if not yet calculated
-     */
-    get calculatedDigest(): string;
-    /**
-     * Creates a new StreamChecksum transform stream.
-     * @param checksum Expected checksum value to validate against
-     * @param algorithm Hash algorithm to use (e.g., 'md5', 'sha256')
-     * @param encoding Encoding for the checksum comparison (defaults to 'base64')
-     */
-    constructor(checksum: string, algorithm: string, encoding?: BinaryToTextEncoding);
-    /**
-     * Transform method that updates the hash with incoming data.
-     * @param chunk Buffer chunk to process
-     * @param _encoding Unused encoding parameter
-     * @param done Callback to signal completion
-     */
-    _transform(chunk: Buffer, _encoding: string, done: () => void): void;
-    /**
-     * Finalization method that validates the checksum.
-     * @param callback Callback called with error if checksum validation fails
-     */
-    _flush(callback: (error?: Error) => void): void;
-}
-/**
- * Factory function that returns either a StreamChecksum transform or a PassThrough stream.
- * Returns PassThrough when no algorithm is provided.
- * @param checksum Expected checksum value
- * @param algorithm Hash algorithm (if empty, returns PassThrough)
- * @param encoding Encoding for checksum comparison
- * @returns StreamChecksum instance or PassThrough stream
- */
-export declare const streamChecksum: (checksum: string, algorithm: string, encoding?: BinaryToTextEncoding) => PassThrough | StreamChecksum;

package/dist/utils/pipes/stream-length.d.ts

@@ -1,22 +0,0 @@
-import { Transform } from "node:stream";
-/**
- * Transform stream that tracks byte length and enforces size limits.
- * Counts total bytes passing through and optionally enforces a maximum limit.
- */
-declare class StreamLength extends Transform {
-    readonly limit: number;
-    length: number;
-    /**
-     * Creates a new StreamLength transform stream.
-     * @param limit Maximum number of bytes allowed (defaults to infinity)
-     */
-    constructor(limit?: number);
-    /**
-     * Transform method that counts bytes and enforces size limits.
-     * @param chunk Buffer chunk to process
-     * @param _encoding Unused encoding parameter
-     * @param callback Callback called with error if limit exceeded
-     */
-    _transform(chunk: Buffer, _encoding: string, callback: (error?: Error) => void): void;
-}
-export default StreamLength;

package/dist/utils/primitives/get-last-one.d.ts

@@ -1,3 +0,0 @@
-/** Return the last element of an array. */
-declare const getLastOne: <T>(value: T[]) => T;
-export default getLastOne;

package/dist/utils/primitives/is-record.d.ts

@@ -1,2 +0,0 @@
-declare const isRecord: (x: unknown) => x is Record<string, unknown>;
-export default isRecord;

package/dist/utils/primitives/map-values.d.ts

@@ -1,9 +0,0 @@
-/**
- * Maps object values using a transformation function.
- * @param object The source object to map values from
- * @param function_ The function to transform each value
- * @returns A new object with transformed values
- * @template T - The type of the transformed values
- */
-declare const mapValues: <T>(object: Record<string, unknown>, function_: (value: unknown) => T) => Record<string, T>;
-export default mapValues;

package/dist/utils/primitives/pick.d.ts

@@ -1,2 +0,0 @@
-declare const pick: <T, K extends keyof T>(object: T, whitelist: K[]) => Pick<T, K>;
-export default pick;

package/dist/utils/primitives/to-milliseconds.d.ts

@@ -1,12 +0,0 @@
-/**
- * Convert a human-readable duration string to milliseconds.
- * @param value Duration value (number in ms or human-readable string)
- * @returns Duration in milliseconds, or undefined if parsing fails
- * @example
- * ```ts
- * toMilliseconds("5m") // 300000
- * toMilliseconds(5000) // 5000
- * ```
- */
-declare const toMilliseconds: (value: number | string | undefined) => number | undefined;
-export default toMilliseconds;

package/dist/utils/primitives/to-seconds.d.ts

@@ -1,12 +0,0 @@
-/**
- * Convert a human-readable duration string to seconds.
- * @param value Duration value (number in seconds or human-readable string)
- * @returns Duration in seconds
- * @example
- * ```ts
- * toSeconds("5m") // 300
- * toSeconds(300) // 300
- * ```
- */
-declare const toSeconds: (value: number | string) => number;
-export default toSeconds;

package/dist/utils/range-checksum.d.ts

@@ -1,33 +0,0 @@
-import type { BinaryToTextEncoding, Hash } from "node:crypto";
-import { Transform } from "node:stream";
-import type { RangeChecksum as IRangeChecksum, RangeHasher as IRangeHasher } from "./types.d.ts";
-/**
- * Transform stream that calculates checksums for specific file ranges.
- * Used for validating partial file integrity during resumable uploads.
- */
-declare class RangeChecksum extends Transform implements IRangeChecksum {
-    readonly path: string;
-    hash: Hash;
-    private readonly hashCopy;
-    private hashes;
-    /**
-     * Creates a new RangeChecksum transform stream.
-     * @param hashes Range hasher instance managing multiple file hashes
-     * @param path File path identifier for this checksum operation
-     */
-    constructor(hashes: IRangeHasher, path: string);
-    /**
-     * Resets the hash state to its initial value.
-     * Useful for reusing the checksum calculator for multiple operations.
-     */
-    reset(): void;
-    /**
-     * Returns the current hash digest in the specified encoding.
-     * @param encoding Output encoding format (default: 'hex')
-     * @returns Hash digest as a string
-     */
-    digest(encoding?: BinaryToTextEncoding): string;
-    _transform(chunk: Buffer, _encoding: string, done: () => void): void;
-    _flush(callback: (error?: Error) => void): void;
-}
-export default RangeChecksum;