mikro-orm-attachments 1.3.2 → 2.0.0

package/dist/converters/ImgkitConverter.d.ts

@@ -0,0 +1,877 @@
+type VariantSpec = BaseConverter<ConvertInput, ConvertOutput>;
+interface ConvertInput {
+	buffer: Buffer;
+	size: number;
+	mimeType: string;
+	variantName?: string;
+	variant?: VariantSpec;
+	extname: string;
+}
+interface ConvertOutput {
+	buffer: Buffer;
+	mimeType: string;
+	extname: string;
+}
+declare abstract class BaseConverter<
+	TInput extends ConvertInput,
+	TOutput extends ConvertOutput
+> {
+	abstract supports(input: TInput): Promise<boolean>;
+	abstract handle(input: TInput): Promise<TOutput>;
+}
+declare namespace exports_index_d {
+	export { writeExifSync, writeExif, version, transformSync, transform, toWebpSync, toWebp, toTensorSync, toTensor, toPngSync, toPng, toJpegSync, toJpeg, thumbnailSync, thumbnailBufferSync, thumbnailBuffer, thumbnail, thumbhashToRgbaSync, thumbhashToRgba, thumbhashToDataUrl, thumbhashSync, thumbhash, stripExifSync, stripExif, smartCropSync, smartCropAnalyzeSync, smartCropAnalyze, smartCrop, resizeSync, resize, metadataSync, metadata, imageHashSync, imageHashDistanceSync, imageHashDistance, imageHash, dominantColorsSync, dominantColors, _default as default, cropSync, crop, blurhashSync, blurhash, WebPOptions, TransformOptions2 as TransformOptions, ThumbnailResult, ThumbnailOptions, ThumbnailFormat, ThumbHashResult, ThumbHashDecodeResult, TensorResult, TensorOptions, TensorNormalization, TensorLayout, TensorDtype, SmartCropOptions, SmartCropBoostRegion, SmartCropAnalysis, ResizeOptions, ResizeFilter, PngOptions, OutputOptions, JpegOptions, ImageMetadata, ImageHashResult, ImageHashOptions, ImageFormat, HashSize, HashAlgorithm, FitMode, ExifOptions, EnhancedTensorResult, DominantColorsResult, DominantColor, CropOptions, CropGravity, BlurHashResult, AvifOptions, AsyncOptions, AspectRatio };
+}
+/**
+* imgkit Types
+*/
+/** Supported image formats */
+type ImageFormat = "jpeg" | "png" | "webp" | "gif" | "bmp" | "ico" | "tiff" | "heic" | "avif";
+/** Resize filter/algorithm */
+type ResizeFilter = "nearest" | "bilinear" | "catmullRom" | "mitchell" | "lanczos3";
+/** Image fit mode for resize */
+type FitMode = "cover" | "contain" | "fill" | "inside" | "outside";
+/** Crop gravity/anchor point */
+type CropGravity = "center" | "north" | "south" | "east" | "west" | "northWest" | "northEast" | "southWest" | "southEast";
+/** Crop options */
+interface CropOptions {
+	/** X coordinate of crop origin (left edge) */
+	x?: number;
+	/** Y coordinate of crop origin (top edge) */
+	y?: number;
+	/** Width of crop region */
+	width?: number;
+	/** Height of crop region */
+	height?: number;
+	/** Aspect ratio string (e.g., "16:9", "1:1", "4:3") */
+	aspectRatio?: string;
+	/** Gravity/anchor point for aspect ratio or dimension-based cropping */
+	gravity?: CropGravity;
+}
+/** Resize options */
+interface ResizeOptions {
+	/** Target width (optional if height is provided) */
+	width?: number;
+	/** Target height (optional if width is provided) */
+	height?: number;
+	/** Resize filter/algorithm (default: lanczos3) */
+	filter?: ResizeFilter;
+	/** Fit mode (default: cover) */
+	fit?: FitMode;
+	/** Background color for padding [r, g, b, a] (default: transparent) */
+	background?: number[];
+}
+/** JPEG encode options */
+interface JpegOptions {
+	/** Quality 1-100 (default: 80) */
+	quality?: number;
+}
+/** PNG encode options */
+interface PngOptions {
+	/** Compression level 0-9 (default: 6) */
+	compression?: number;
+}
+/** WebP encode options */
+interface WebPOptions {
+	/** Quality 1-100 for lossy, ignored for lossless (default: 80) */
+	quality?: number;
+	/** Use lossless compression (default: false) */
+	lossless?: boolean;
+}
+/** AVIF encode options */
+interface AvifOptions {
+	/** Quality 1-100 (default: 80) */
+	quality?: number;
+	/** Speed 1-10, higher is faster but lower quality (default: 6) */
+	speed?: number;
+}
+/** Output format options */
+interface OutputOptions {
+	/** Output format */
+	format: ImageFormat;
+	/** JPEG options (if format is jpeg) */
+	jpeg?: JpegOptions;
+	/** PNG options (if format is png) */
+	png?: PngOptions;
+	/** WebP options (if format is webp) */
+	webp?: WebPOptions;
+	/** AVIF options (if format is avif) */
+	avif?: AvifOptions;
+}
+/** Image metadata (sharp-compatible) */
+interface ImageMetadata {
+	/** Image width in pixels */
+	width: number;
+	/** Image height in pixels */
+	height: number;
+	/** Detected format (jpeg, png, webp, gif, bmp, ico, tiff) */
+	format: string;
+	/** File size in bytes */
+	size?: number;
+	/** Color space (srgb, rgb, grayscale) */
+	space: string;
+	/** Number of channels (1, 2, 3, or 4) */
+	channels: number;
+	/** Bit depth per sample (uchar = 8-bit, ushort = 16-bit) */
+	depth: string;
+	/** Whether the image has an alpha channel */
+	hasAlpha: boolean;
+	/** Bits per sample */
+	bitsPerSample: number;
+	/** Whether the image is progressive (JPEG) or interlaced (PNG) */
+	isProgressive: boolean;
+	/** Whether the image uses palette/indexed colors (PNG/GIF) */
+	isPalette: boolean;
+	/** Whether the image has an embedded ICC profile */
+	hasProfile: boolean;
+	/** EXIF orientation value (1-8, if present) */
+	orientation?: number;
+	/** Page/frame count for multi-page images (GIF, TIFF) */
+	pages?: number;
+	/** Loop count for animated images */
+	loopCount?: number;
+	/** Delay between frames in ms (for animated images) */
+	delay?: number[];
+	/** Background color (for GIF) */
+	background?: number[];
+	/** Compression type used */
+	compression?: string;
+	/** Density/DPI info */
+	density?: number;
+}
+/** Blurhash result */
+interface BlurHashResult {
+	/** The blurhash string */
+	hash: string;
+	/** Original width */
+	width: number;
+	/** Original height */
+	height: number;
+}
+/** ThumbHash result */
+interface ThumbHashResult {
+	/** The thumbhash bytes (typically ~25 bytes) */
+	hash: Buffer;
+	/** Base64 data URL for inline CSS/HTML usage */
+	dataUrl: string;
+	/** Original width */
+	width: number;
+	/** Original height */
+	height: number;
+	/** Whether image has alpha channel */
+	hasAlpha: boolean;
+}
+/** Decoded thumbhash result (RGBA pixels) */
+interface ThumbHashDecodeResult {
+	/** RGBA pixel data */
+	rgba: Buffer;
+	/** Decoded width */
+	width: number;
+	/** Decoded height */
+	height: number;
+}
+/** EXIF metadata options for writing */
+interface ExifOptions {
+	/** Image description / caption / AI prompt */
+	imageDescription?: string;
+	/** Artist / creator name */
+	artist?: string;
+	/** Copyright notice */
+	copyright?: string;
+	/** Software used to create the image */
+	software?: string;
+	/** Date/time in EXIF format (YYYY:MM:DD HH:MM:SS) */
+	dateTime?: string;
+	/** Original date/time in EXIF format */
+	dateTimeOriginal?: string;
+	/** User comment (can contain JSON or other data) */
+	userComment?: string;
+	/** Camera/device make */
+	make?: string;
+	/** Camera/device model */
+	model?: string;
+	/** Orientation (1-8) */
+	orientation?: number;
+}
+/** Transform options (all-in-one processing) */
+interface TransformOptions2 {
+	/** Crop options (applied before resize) */
+	crop?: CropOptions;
+	/** Resize options */
+	resize?: ResizeOptions;
+	/** Output options */
+	output?: OutputOptions;
+	/** Rotate degrees (90, 180, 270) */
+	rotate?: number;
+	/** Flip horizontally */
+	flipH?: boolean;
+	/** Flip vertically */
+	flipV?: boolean;
+	/** Grayscale conversion */
+	grayscale?: boolean;
+	/** Blur radius (0-100) */
+	blur?: number;
+	/** Sharpen amount (0-100) */
+	sharpen?: number;
+	/** Brightness adjustment (-100 to 100) */
+	brightness?: number;
+	/** Contrast adjustment (-100 to 100) */
+	contrast?: number;
+	/** EXIF metadata to write (for JPEG/WebP output) */
+	exif?: ExifOptions;
+}
+/** Tensor data type */
+type TensorDtype = "Float32" | "Uint8";
+/** Tensor memory layout */
+type TensorLayout = "Chw" | "Hwc";
+/** Normalization preset */
+type TensorNormalization = "Imagenet" | "Clip" | "ZeroOne" | "NegOneOne" | "None";
+/** Tensor conversion options */
+interface TensorOptions {
+	/** Output data type (default: Float32) */
+	dtype?: TensorDtype;
+	/** Memory layout: 'Chw' for PyTorch/ONNX, 'Hwc' for TensorFlow (default: Chw) */
+	layout?: TensorLayout;
+	/** Normalization preset (default: None) */
+	normalization?: TensorNormalization;
+	/** Target width for resize before conversion */
+	width?: number;
+	/** Target height for resize before conversion */
+	height?: number;
+	/** Add batch dimension (default: false) */
+	batch?: boolean;
+}
+/** Tensor conversion result */
+interface TensorResult {
+	/** Raw tensor data as bytes (use toFloat32Array() or toUint8Array() to convert) */
+	data: Buffer;
+	/** Shape array (e.g., [3, 224, 224] or [1, 3, 224, 224] with batch) */
+	shape: number[];
+	/** Data type used */
+	dtype: TensorDtype;
+	/** Memory layout used */
+	layout: TensorLayout;
+	/** Image width */
+	width: number;
+	/** Image height */
+	height: number;
+	/** Number of channels (always 3 for RGB) */
+	channels: number;
+}
+/** Perceptual hash algorithm */
+type HashAlgorithm = "PHash" | "DHash" | "AHash" | "BlockHash";
+/** Hash size (dimensions of the hash grid) */
+type HashSize = "Size8" | "Size16" | "Size32";
+/** Perceptual hash options */
+interface ImageHashOptions {
+	/** Hash algorithm (default: PHash) */
+	algorithm?: HashAlgorithm;
+	/** Hash size (default: Size8) */
+	size?: HashSize;
+}
+/** Perceptual hash result */
+interface ImageHashResult {
+	/** The hash as a base64-encoded string */
+	hash: string;
+	/** Original image width */
+	width: number;
+	/** Original image height */
+	height: number;
+	/** Hash size used (8, 16, or 32) */
+	hashSize: number;
+	/** Algorithm used */
+	algorithm: string;
+}
+/** Common aspect ratios for smart crop */
+type AspectRatio = "1:1" | "16:9" | "9:16" | "4:3" | "3:2" | "21:9" | string;
+/** Boost region for smart crop (prioritize specific areas) */
+interface SmartCropBoostRegion {
+	/** X coordinate of the region */
+	x: number;
+	/** Y coordinate of the region */
+	y: number;
+	/** Width of the region */
+	width: number;
+	/** Height of the region */
+	height: number;
+	/** Weight of the boost (0.0 - 1.0) */
+	weight: number;
+}
+/** Smart crop options */
+interface SmartCropOptions {
+	/** Target width */
+	width?: number;
+	/** Target height */
+	height?: number;
+	/** Aspect ratio string (e.g., "16:9", "1:1", "4:3") */
+	aspectRatio?: AspectRatio;
+	/** Boost regions (areas to prioritize) */
+	boost?: SmartCropBoostRegion[];
+}
+/** Smart crop analysis result (crop coordinates without actual cropping) */
+interface SmartCropAnalysis {
+	/** X coordinate of the best crop */
+	x: number;
+	/** Y coordinate of the best crop */
+	y: number;
+	/** Width of the best crop */
+	width: number;
+	/** Height of the best crop */
+	height: number;
+	/** Score of the best crop (higher is better) */
+	score: number;
+}
+/** A single dominant color */
+interface DominantColor {
+	/** Red component (0-255) */
+	r: number;
+	/** Green component (0-255) */
+	g: number;
+	/** Blue component (0-255) */
+	b: number;
+	/** Hex color string (e.g., "#FF5733") */
+	hex: string;
+}
+/** Dominant colors extraction result */
+interface DominantColorsResult {
+	/** Array of dominant colors (sorted by prominence) */
+	colors: DominantColor[];
+	/** The most dominant color (same as colors[0]) */
+	primary: DominantColor;
+}
+/** Output format for thumbnail */
+type ThumbnailFormat = "Jpeg" | "Png" | "Webp";
+/** Options for fast thumbnail generation */
+interface ThumbnailOptions {
+	/** Target width (required) */
+	width: number;
+	/** Target height (optional, maintains aspect ratio if not set) */
+	height?: number;
+	/** Output format (default: same as input, or JPEG for best speed) */
+	format?: ThumbnailFormat;
+	/** JPEG/WebP quality 1-100 (default: 80, or 70 in fast mode) */
+	quality?: number;
+	/**
+	* Enable shrink-on-load optimization (default: true)
+	*
+	* When true, decodes image at reduced resolution before resize.
+	* This is 2-10x faster for large images being downscaled.
+	*
+	* - JPEG: Uses libjpeg-turbo scale factors (1/2, 1/4, 1/8)
+	* - WebP: Uses libwebp native scaling during decode
+	*/
+	shrinkOnLoad?: boolean;
+	/** Resize filter (default: auto-select based on scale factor) */
+	filter?: ResizeFilter;
+	/**
+	* Enable fast mode for maximum speed (default: false)
+	*
+	* When true, applies aggressive optimizations:
+	* - More aggressive shrink-on-load (1/8 instead of 1/4 when possible)
+	* - Skips final resize if within 15% of target dimensions
+	* - Uses Nearest neighbor filter for any remaining resize
+	* - Uses lower quality (70 instead of 80)
+	*
+	* This can be 2-4x faster than normal mode with slight quality tradeoff.
+	* Best for generating preview thumbnails where exact dimensions don't matter.
+	*/
+	fastMode?: boolean;
+}
+/** Fast thumbnail result with metadata */
+interface ThumbnailResult {
+	/** The thumbnail image data */
+	data: Buffer;
+	/** Output width */
+	width: number;
+	/** Output height */
+	height: number;
+	/** Output format used */
+	format: string;
+	/** Whether shrink-on-load was used */
+	shrinkOnLoadUsed: boolean;
+	/** Original image width */
+	originalWidth: number;
+	/** Original image height */
+	originalHeight: number;
+}
+/** Options for async operations (timeout and cancellation) */
+interface AsyncOptions {
+	/** Timeout in milliseconds. Operation rejects after this duration. */
+	timeoutMs?: number;
+	/** AbortSignal for cancellation. Operation rejects when signal is aborted. */
+	signal?: AbortSignal;
+}
+/**
+* Metadata API functions
+*/
+/**
+* Get image metadata asynchronously
+*
+* @param input - Image buffer
+* @param asyncOptions - Timeout and cancellation options
+* @returns Promise resolving to image metadata
+*
+* @example
+* ```typescript
+* const info = await metadata(imageBuffer);
+* console.log(`${info.width}x${info.height} ${info.format}`);
+*
+* // With timeout
+* const info = await metadata(imageBuffer, { timeoutMs: 5000 });
+*
+* // With AbortSignal
+* const controller = new AbortController();
+* const info = await metadata(imageBuffer, { signal: controller.signal });
+* ```
+*/
+declare function metadata(input: Buffer, asyncOptions?: AsyncOptions): Promise<ImageMetadata>;
+/**
+* Get image metadata synchronously
+*/
+declare function metadataSync(input: Buffer): ImageMetadata;
+/**
+* Resize API functions
+*/
+/**
+* Resize image asynchronously
+*
+* @param input - Image buffer
+* @param options - Resize options
+* @param asyncOptions - Timeout and cancellation options
+* @returns Promise resolving to resized image buffer (PNG)
+*
+* @example
+* ```typescript
+* // Resize to specific dimensions
+* const resized = await resize(imageBuffer, { width: 800, height: 600 });
+*
+* // With timeout
+* const resized = await resize(imageBuffer, { width: 800 }, { timeoutMs: 5000 });
+* ```
+*/
+declare function resize(input: Buffer, options: ResizeOptions, asyncOptions?: AsyncOptions): Promise<Buffer>;
+/**
+* Resize image synchronously
+*/
+declare function resizeSync(input: Buffer, options: ResizeOptions): Buffer;
+/**
+* Crop API functions
+*/
+/**
+* Crop an image asynchronously
+*
+* @param input - Image buffer
+* @param options - Crop options
+* @param asyncOptions - Timeout and cancellation options
+* @returns Cropped image as PNG buffer
+*
+* @example
+* ```typescript
+* const cropped = await crop(input, { x: 100, y: 50, width: 800, height: 600 });
+*
+* // With timeout
+* const cropped = await crop(input, { aspectRatio: "1:1" }, { timeoutMs: 5000 });
+* ```
+*/
+declare function crop(input: Buffer, options: CropOptions, asyncOptions?: AsyncOptions): Promise<Buffer>;
+/**
+* Crop an image synchronously
+*/
+declare function cropSync(input: Buffer, options: CropOptions): Buffer;
+/**
+* Image encoding/format conversion API functions
+*/
+/**
+* Convert image to JPEG asynchronously
+*
+* @param input - Image buffer
+* @param options - JPEG encoding options
+* @param asyncOptions - Timeout and cancellation options
+* @returns Promise resolving to JPEG buffer
+*
+* @example
+* ```typescript
+* const jpeg = await toJpeg(imageBuffer, { quality: 85 });
+*
+* // With timeout
+* const jpeg = await toJpeg(imageBuffer, { quality: 85 }, { timeoutMs: 5000 });
+* ```
+*/
+declare function toJpeg(input: Buffer, options?: JpegOptions, asyncOptions?: AsyncOptions): Promise<Buffer>;
+/**
+* Convert image to JPEG synchronously
+*/
+declare function toJpegSync(input: Buffer, options?: JpegOptions): Buffer;
+/**
+* Convert image to PNG asynchronously
+*
+* @param input - Image buffer
+* @param options - PNG encoding options
+* @param asyncOptions - Timeout and cancellation options
+* @returns Promise resolving to PNG buffer
+*/
+declare function toPng(input: Buffer, options?: PngOptions, asyncOptions?: AsyncOptions): Promise<Buffer>;
+/**
+* Convert image to PNG synchronously
+*/
+declare function toPngSync(input: Buffer, options?: PngOptions): Buffer;
+/**
+* Convert image to WebP asynchronously
+*
+* @param input - Image buffer
+* @param options - WebP encoding options
+* @param asyncOptions - Timeout and cancellation options
+* @returns Promise resolving to WebP buffer
+*/
+declare function toWebp(input: Buffer, options?: WebPOptions, asyncOptions?: AsyncOptions): Promise<Buffer>;
+/**
+* Convert image to WebP synchronously
+*/
+declare function toWebpSync(input: Buffer, options?: WebPOptions): Buffer;
+/**
+* Transform API functions
+*/
+/**
+* Transform image with multiple operations asynchronously
+*
+* @param input - Image buffer
+* @param options - Transform options
+* @param asyncOptions - Timeout and cancellation options
+* @returns Promise resolving to transformed image buffer
+*
+* @example
+* ```typescript
+* const result = await transform(imageBuffer, {
+*   resize: { width: 800, height: 600 },
+*   rotate: 90,
+*   grayscale: true,
+*   output: { format: 'webp', webp: { quality: 85 } }
+* }, { timeoutMs: 10000 });
+* ```
+*/
+declare function transform(input: Buffer, options: TransformOptions2, asyncOptions?: AsyncOptions): Promise<Buffer>;
+/**
+* Transform image with multiple operations synchronously
+*/
+declare function transformSync(input: Buffer, options: TransformOptions2): Buffer;
+/**
+* Blurhash API functions
+*/
+/**
+* Generate blurhash from image asynchronously
+*
+* @param input - Image buffer
+* @param componentsX - Number of X components (default: 4)
+* @param componentsY - Number of Y components (default: 3)
+* @param asyncOptions - Timeout and cancellation options
+* @returns Promise resolving to blurhash result
+*
+* @example
+* ```typescript
+* const { hash, width, height } = await blurhash(imageBuffer);
+*
+* // With timeout
+* const { hash } = await blurhash(imageBuffer, 4, 3, { timeoutMs: 5000 });
+* ```
+*/
+declare function blurhash(input: Buffer, componentsX?: number, componentsY?: number, asyncOptions?: AsyncOptions): Promise<BlurHashResult>;
+/**
+* Generate blurhash from image synchronously
+*/
+declare function blurhashSync(input: Buffer, componentsX?: number, componentsY?: number): BlurHashResult;
+/**
+* ThumbHash API functions
+*
+* ThumbHash is a compact image placeholder that produces smoother,
+* more visually pleasing placeholders compared to BlurHash.
+*/
+/**
+* Generate thumbhash from image asynchronously
+*
+* @param input - Image buffer (JPEG, PNG, WebP, etc.)
+* @param asyncOptions - Timeout and cancellation options
+* @returns Promise resolving to thumbhash result with data URL
+*
+* @example
+* ```typescript
+* const { hash, dataUrl } = await thumbhash(imageBuffer);
+*
+* // With timeout
+* const { hash } = await thumbhash(imageBuffer, { timeoutMs: 5000 });
+* ```
+*/
+declare function thumbhash(input: Buffer, asyncOptions?: AsyncOptions): Promise<ThumbHashResult>;
+/**
+* Generate thumbhash from image synchronously
+*/
+declare function thumbhashSync(input: Buffer): ThumbHashResult;
+/**
+* Decode thumbhash back to RGBA pixels asynchronously
+*
+* @param hash - ThumbHash bytes
+* @param asyncOptions - Timeout and cancellation options
+* @returns Promise resolving to RGBA pixels and dimensions
+*/
+declare function thumbhashToRgba(hash: Buffer, asyncOptions?: AsyncOptions): Promise<ThumbHashDecodeResult>;
+/**
+* Decode thumbhash back to RGBA pixels synchronously
+*/
+declare function thumbhashToRgbaSync(hash: Buffer): ThumbHashDecodeResult;
+/**
+* Convert thumbhash to data URL (helper function)
+*
+* @param hash - ThumbHash bytes
+* @returns Base64 data URL string
+*/
+declare function thumbhashToDataUrl(hash: Buffer): string;
+/**
+* EXIF metadata API functions
+*/
+/**
+* Write EXIF metadata to an image asynchronously
+*
+* Supports JPEG and WebP formats.
+*
+* @param input - Image buffer
+* @param options - EXIF metadata options
+* @param asyncOptions - Timeout and cancellation options
+* @returns Promise resolving to image buffer with EXIF data
+*/
+declare function writeExif(input: Buffer, options: ExifOptions, asyncOptions?: AsyncOptions): Promise<Buffer>;
+/**
+* Write EXIF metadata to an image synchronously
+*/
+declare function writeExifSync(input: Buffer, options: ExifOptions): Buffer;
+/**
+* Strip all EXIF metadata from an image asynchronously
+*
+* Supports JPEG and WebP formats.
+*
+* @param input - Image buffer
+* @param asyncOptions - Timeout and cancellation options
+* @returns Promise resolving to image buffer without EXIF data
+*/
+declare function stripExif(input: Buffer, asyncOptions?: AsyncOptions): Promise<Buffer>;
+/**
+* Strip all EXIF metadata from an image synchronously
+*/
+declare function stripExifSync(input: Buffer): Buffer;
+/**
+* Tensor conversion API
+* Convert images to tensor format for ML frameworks
+*/
+/**
+* Enhanced tensor result with helper methods
+*/
+interface EnhancedTensorResult extends TensorResult {
+	/** Convert data to Float32Array (for Float32 dtype) */
+	toFloat32Array(): Float32Array;
+	/** Convert data to Uint8Array (for Uint8 dtype) */
+	toUint8Array(): Uint8Array;
+}
+/**
+* Convert image to tensor format for ML frameworks
+*
+* @param input - Image buffer (JPEG, PNG, WebP, etc.)
+* @param options - Tensor conversion options
+* @param asyncOptions - Timeout and cancellation options
+* @returns Tensor data with shape and metadata
+*/
+declare function toTensor(input: Buffer, options?: TensorOptions, asyncOptions?: AsyncOptions): Promise<EnhancedTensorResult>;
+/**
+* Convert image to tensor format synchronously
+*/
+declare function toTensorSync(input: Buffer, options?: TensorOptions): EnhancedTensorResult;
+/**
+* Perceptual hashing API for image similarity detection
+*/
+/**
+* Generate a perceptual hash from an image asynchronously
+*
+* @param input - Image buffer (JPEG, PNG, WebP, etc.)
+* @param options - Hash options (algorithm, size)
+* @param asyncOptions - Timeout and cancellation options
+* @returns Promise resolving to ImageHashResult with hash string
+*
+* @example
+* ```typescript
+* const result = await imageHash(buffer);
+*
+* // With timeout
+* const result = await imageHash(buffer, { algorithm: 'PHash' }, { timeoutMs: 5000 });
+* ```
+*/
+declare function imageHash(input: Buffer, options?: ImageHashOptions, asyncOptions?: AsyncOptions): Promise<ImageHashResult>;
+/**
+* Generate a perceptual hash from an image synchronously
+*/
+declare function imageHashSync(input: Buffer, options?: ImageHashOptions): ImageHashResult;
+/**
+* Calculate the hamming distance between two perceptual hashes asynchronously
+*
+* @param hash1 - First hash (base64 string from imageHash)
+* @param hash2 - Second hash (base64 string from imageHash)
+* @param asyncOptions - Timeout and cancellation options
+* @returns Promise resolving to hamming distance
+*/
+declare function imageHashDistance(hash1: string, hash2: string, asyncOptions?: AsyncOptions): Promise<number>;
+/**
+* Calculate the hamming distance between two perceptual hashes synchronously
+*/
+declare function imageHashDistanceSync(hash1: string, hash2: string): number;
+/**
+* Smart Crop API for content-aware image cropping
+*/
+/**
+* Smart crop an image using content-aware detection asynchronously
+*
+* @param input - Image buffer (JPEG, PNG, WebP, etc.)
+* @param options - Smart crop options (width, height, or aspectRatio)
+* @param asyncOptions - Timeout and cancellation options
+* @returns Promise resolving to cropped image buffer (PNG format)
+*/
+declare function smartCrop(input: Buffer, options: SmartCropOptions, asyncOptions?: AsyncOptions): Promise<Buffer>;
+/**
+* Smart crop an image using content-aware detection synchronously
+*/
+declare function smartCropSync(input: Buffer, options: SmartCropOptions): Buffer;
+/**
+* Analyze an image and find the best crop region asynchronously
+*
+* @param input - Image buffer (JPEG, PNG, WebP, etc.)
+* @param options - Smart crop options (width, height, or aspectRatio)
+* @param asyncOptions - Timeout and cancellation options
+* @returns Promise resolving to SmartCropAnalysis with crop coordinates and score
+*/
+declare function smartCropAnalyze(input: Buffer, options: SmartCropOptions, asyncOptions?: AsyncOptions): Promise<SmartCropAnalysis>;
+/**
+* Analyze an image and find the best crop region synchronously
+*/
+declare function smartCropAnalyzeSync(input: Buffer, options: SmartCropOptions): SmartCropAnalysis;
+/**
+* Dominant Color Extraction API
+*/
+/**
+* Extract dominant colors from an image asynchronously
+*
+* @param input - Image buffer (JPEG, PNG, WebP, etc.)
+* @param count - Maximum number of colors to extract (default: 5)
+* @param asyncOptions - Timeout and cancellation options
+* @returns Promise resolving to DominantColorsResult with colors array and primary color
+*/
+declare function dominantColors(input: Buffer, count?: number, asyncOptions?: AsyncOptions): Promise<DominantColorsResult>;
+/**
+* Extract dominant colors from an image synchronously
+*/
+declare function dominantColorsSync(input: Buffer, count?: number): DominantColorsResult;
+/**
+* Fast Thumbnail API
+*
+* Optimized thumbnail generation with shrink-on-load support.
+*/
+/**
+* Generate a fast thumbnail synchronously
+*/
+declare function thumbnailSync(input: Buffer, options: ThumbnailOptions): ThumbnailResult;
+/**
+* Generate a fast thumbnail asynchronously
+*
+* @param input - Image buffer (JPEG, PNG, WebP, etc.)
+* @param options - Thumbnail options
+* @param asyncOptions - Timeout and cancellation options
+* @returns Promise resolving to thumbnail result with image data and metadata
+*/
+declare function thumbnail(input: Buffer, options: ThumbnailOptions, asyncOptions?: AsyncOptions): Promise<ThumbnailResult>;
+/**
+* Generate a fast thumbnail and return just the buffer synchronously
+*/
+declare function thumbnailBufferSync(input: Buffer, options: ThumbnailOptions): Buffer;
+/**
+* Generate a fast thumbnail and return just the buffer asynchronously
+*
+* @param input - Image buffer
+* @param options - Thumbnail options
+* @param asyncOptions - Timeout and cancellation options
+* @returns Promise resolving to image buffer
+*/
+declare function thumbnailBuffer(input: Buffer, options: ThumbnailOptions, asyncOptions?: AsyncOptions): Promise<Buffer>;
+/**
+* imgkit - High-performance image processing for Bun and Node.js
+*
+* @module imgkit
+* @author Aissam Irhir <aissamirhir@gmail.com>
+*
+* @example
+* ```typescript
+* import { resize, toWebp, metadata } from 'imgkit';
+*
+* // Read image
+* const input = await Bun.file('input.jpg').arrayBuffer();
+*
+* // Resize image
+* const resized = await resize(Buffer.from(input), { width: 800, height: 600 });
+*
+* // Convert to WebP
+* const webp = await toWebp(Buffer.from(input), { quality: 85 });
+*
+* // Get metadata
+* const info = await metadata(Buffer.from(input));
+* console.log(info.width, info.height, info.format);
+* ```
+*/
+/**
+* Get library version
+*/
+declare function version(): string;
+declare const _default: {
+	metadata: typeof metadata;
+	metadataSync: typeof metadataSync;
+	resize: typeof resize;
+	resizeSync: typeof resizeSync;
+	crop: typeof crop;
+	cropSync: typeof cropSync;
+	toJpeg: typeof toJpeg;
+	toJpegSync: typeof toJpegSync;
+	toPng: typeof toPng;
+	toPngSync: typeof toPngSync;
+	toWebp: typeof toWebp;
+	toWebpSync: typeof toWebpSync;
+	transform: typeof transform;
+	transformSync: typeof transformSync;
+	blurhash: typeof blurhash;
+	blurhashSync: typeof blurhashSync;
+	thumbhash: typeof thumbhash;
+	thumbhashSync: typeof thumbhashSync;
+	thumbhashToRgba: typeof thumbhashToRgba;
+	thumbhashToRgbaSync: typeof thumbhashToRgbaSync;
+	thumbhashToDataUrl: typeof thumbhashToDataUrl;
+	writeExif: typeof writeExif;
+	writeExifSync: typeof writeExifSync;
+	stripExif: typeof stripExif;
+	stripExifSync: typeof stripExifSync;
+	toTensor: typeof toTensor;
+	toTensorSync: typeof toTensorSync;
+	imageHash: typeof imageHash;
+	imageHashSync: typeof imageHashSync;
+	imageHashDistance: typeof imageHashDistance;
+	imageHashDistanceSync: typeof imageHashDistanceSync;
+	smartCrop: typeof smartCrop;
+	smartCropSync: typeof smartCropSync;
+	smartCropAnalyze: typeof smartCropAnalyze;
+	smartCropAnalyzeSync: typeof smartCropAnalyzeSync;
+	dominantColors: typeof dominantColors;
+	dominantColorsSync: typeof dominantColorsSync;
+	thumbnail: typeof thumbnail;
+	thumbnailSync: typeof thumbnailSync;
+	thumbnailBuffer: typeof thumbnailBuffer;
+	thumbnailBufferSync: typeof thumbnailBufferSync;
+	version: typeof version;
+};
+interface ImgkitConverterOptions extends exports_index_d.TransformOptions {}
+declare class ImgkitConverter extends BaseConverter<ConvertInput, ConvertOutput> {
+	private readonly options?;
+	constructor(options?: ImgkitConverterOptions | undefined);
+	supports(input: ConvertInput): Promise<boolean>;
+	handle(input: ConvertInput): Promise<ConvertOutput>;
+}
+export { ImgkitConverter };