@keeratita/heic-converter 0.4.2 → 0.5.0

package/dist/index.d.mts

@@ -1,8 +1,59 @@
 interface DecodedImage {
     width: number;
     height: number;
+    /**
+     * RGBA pixel data, interleaved, row-major, 4 bytes per pixel.
+     *
+     * The buffer is always a plain `ArrayBuffer` owned by the returned array
+     * (never a view into the WASM heap), so it stays valid after
+     * `LibheifDecoder.free()` and can be passed directly to
+     * `new ImageData(...)` / `putImageData` — including the `ImageData`
+     * overload that requires `Uint8ClampedArray<ArrayBuffer>` under TS >= 5.7.
+     */
     data: Uint8ClampedArray;
+    /**
+     * Raw EXIF block copied from the source file, normalized to the JPEG APP1
+     * payload form: `"Exif\0\0"` followed by the TIFF structure. Present when
+     * the file carries an Exif item — including files where libheif already
+     * applied `irot`/`imir` (the block is reported independently of
+     * {@link DecodedImage.orientation}).
+     *
+     * `convertHeic` re-injects this block into JPEG (APP1) and PNG (`eXIf`)
+     * output when `preserveExif: true`; raw-decode consumers can attach it to
+     * their own encoder output (e.g. `sharp`'s `.withMetadata({ exif })`).
+     * Owned by the returned object; never a WASM-heap view.
+     */
+    exif?: Uint8Array;
+    /**
+     * EXIF orientation of the **stored** pixels (1–8, EXIF tag 274 semantics;
+     * 1 = upright). Absent or 1 means no rotation is pending.
+     *
+     * libheif already applies `irot`/`imir` container transforms during
+     * decode — for those files this is 1 and the pixels are upright. A value
+     * > 1 means the orientation comes only from the Exif item: `convertHeic`
+     * applies it automatically (unless `applyOrientation: false`), while raw
+     * `decode()` consumers get stored pixels and must apply it themselves.
+     * Decoders that do not report orientation may omit this field.
+     */
+    orientation?: number;
 }
+/**
+ * Decoder contract used by {@link ConvertOptions.decoder} /
+ * {@link ConvertManyOptions.decoder} and implemented by `LibheifDecoder`.
+ *
+ * Lifecycle rules followed by the library (implementations may rely on them):
+ * - `initialize()` is called before every `decode()`; implementations must
+ *   make repeated/concurrent calls cheap (e.g. memoize the load promise).
+ * - `decode()` is awaited before the library calls `free()`; the returned
+ *   `DecodedImage` must therefore not reference decoder-owned memory that
+ *   `free()` releases (copy pixels out, as `LibheifDecoder` does).
+ * - `free()` is called at most once per conversion. Decoders **injected** via
+ *   options are never freed by the library — the caller owns their lifetime.
+ *
+ * Concurrency: with `convertMany`, a single injected decoder is shared by
+ * all concurrent conversions, so `decode()` must be safe to call concurrently
+ * on one instance (no shared mutable state across in-flight decodes).
+ */
 interface IHeicDecoder {
     /**
      * Initializes the decoder (e.g., loading WebAssembly module).
@@ -15,12 +66,51 @@ interface IHeicDecoder {
      */
     decode(data: Uint8Array, onProgress?: (percent: number) => void): Promise<DecodedImage>;
     /**
-     * Cleans up allocated resources.
+     * Cleans up allocated resources. Idempotent: safe to call multiple times.
      */
     free(): void;
 }
-type ImageFormat = 'jpeg' | 'jpg' | 'png' | 'svg' | 'webp';
+type ImageFormat = 'jpeg' | 'jpg' | 'png' | 'svg' | 'webp' | 'avif';
+/**
+ * Formats accepted by {@link ConvertOptions.to} (case-insensitive).
+ * `'jpg'` is an alias of `'jpeg'`. `'avif'` requires an environment whose
+ * canvas can encode AVIF (Chromium/Firefox today); elsewhere it rejects with
+ * `format_unsupported`.
+ */
+declare const SUPPORTED_FORMATS: readonly ImageFormat[];
+/** Default JPEG/WebP encoding quality used when `quality` is not provided. */
+declare const DEFAULT_QUALITY = 0.92;
 type HeicInput = Blob | File | ArrayBuffer | Uint8Array;
+/**
+ * How {@link convertHeic} returns the converted image.
+ * - `'blob'` — a `Blob` (the default; browser-native, works everywhere)
+ * - `'dataUrl'` — a `data:image/...;base64,…` string (previews, `<img src>`)
+ * - `'arrayBuffer'` — raw bytes (uploads, WebCodecs, Node-friendly transfer)
+ */
+type OutputShape = 'blob' | 'dataUrl' | 'arrayBuffer';
+/** Resolved return type of `convertHeic`/`convertMany` for an output shape. */
+type ConvertResult<S extends OutputShape> = S extends 'dataUrl' ? string : S extends 'arrayBuffer' ? ArrayBuffer : Blob;
+/** Crop rectangle in **post-orientation display pixels** (top-left origin). */
+interface CropOptions {
+    /** Left edge of the crop box. @default 0 */
+    x?: number;
+    /** Top edge of the crop box. @default 0 */
+    y?: number;
+    /** Crop width in pixels. Must be a positive integer and fit inside the image. */
+    width: number;
+    /** Crop height in pixels. Must be a positive integer and fit inside the image. */
+    height: number;
+}
+/** Per-item outcome when `continueOnError: true`. */
+type ConvertItemResult<T = Blob> = {
+    index: number;
+    ok: true;
+    result: T;
+} | {
+    index: number;
+    ok: false;
+    error: Error;
+};
 interface ResizeOptions {
     /**
      * Maximum width in pixels. The image is downscaled to fit within this
@@ -42,25 +132,70 @@ interface ResizeOptions {
 }
 interface ConvertOptions extends ResizeOptions {
     /**
-     * Target format for the conversion.
+     * Target format for the conversion. Must be one of the values in
+     * {@link SUPPORTED_FORMATS}; an unknown value is rejected up front,
+     * before the input is decoded.
      * @default 'jpeg'
      */
     to?: ImageFormat;
     /**
-     * Quality of the converted image (between 0.0 and 1.0).
-     * Applicable for 'jpeg', 'jpg', and 'webp' formats.
+     * Quality of the converted image, between 0.0 and 1.0 (inclusive).
+     * Applicable for 'jpeg', 'jpg', 'webp', and 'avif' formats — but validated
+     * for every format: passing an out-of-range value (e.g. `90` from a 0-100
+     * scale) throws regardless of `to`.
      * @default 0.92
      */
     quality?: number;
     /**
      * Optional custom decoder implementation to inject.
      * If not provided, a default LibheifDecoder is used.
+     * The library never calls `free()` on an injected decoder.
      */
     decoder?: IHeicDecoder;
     /**
-     * Optional progress callback that receives the progress percentage (0 to 100) during decoding.
+     * Optional progress callback that receives the progress percentage during
+     * decoding. Values are normalized and clamped to the range 0 to 100; the
+     * final 100% is emitted only when the conversion succeeds. A callback that
+     * throws rejects the conversion with `progress_callback_failed`.
      */
     onProgress?: (percent: number) => void;
+    /**
+     * Rotate/flip the output so it matches the source's EXIF orientation
+     * (applied as a canvas transform during rendering; `irot`/`imir` container
+     * transforms are already applied by the decoder and never stacked on top).
+     * Set `false` to keep the exact stored-pixel geometry. A non-boolean value
+     * is rejected up front with `invalid_input`.
+     * @default true
+     */
+    applyOrientation?: boolean;
+    /**
+     * Representation of the converted image. See {@link OutputShape}.
+     * @default 'blob'
+     */
+    output?: OutputShape;
+    /**
+     * AbortSignal that cancels the conversion. Cancellation is checked at
+     * stage boundaries (input read, decoder init, before/after decode,
+     * before encode) and aborts `convertHeicInWorker` calls immediately by
+     * terminating the worker; the synchronous WASM decode itself cannot be
+     * preempted mid-call. An aborted signal rejects with code `aborted`.
+     */
+    signal?: AbortSignal;
+    /**
+     * Crop rectangle in post-orientation display pixels (the geometry the
+     * image will be displayed in). Applied before resize: `scale`/`maxWidth`/
+     * `maxHeight` then downscale the cropped region. Out-of-bounds crops
+     * reject with `invalid_crop`.
+     */
+    crop?: CropOptions;
+    /**
+     * Copy the source HEIC's EXIF block into JPEG (APP1) and PNG (`eXIf`
+     * chunk) output so converted files keep camera metadata (orientation,
+     * GPS, timestamps). Note this **preserves private data** like GPS — set
+     * deliberately. Ignored for `webp`/`svg` output.
+     * @default false
+     */
+    preserveExif?: boolean;
 }
 interface ConvertManyOptions extends Omit<ConvertOptions, 'onProgress'> {
     /**
@@ -69,17 +204,36 @@ interface ConvertManyOptions extends Omit<ConvertOptions, 'onProgress'> {
      */
     concurrency?: number;
     /**
-     * Optional progress callback that receives the item index and its
-     * progress percentage (0 to 100) during decoding.
+     * Optional progress callback that receives the item index (0-based) and
+     * its progress percentage (normalized to 0 to 100) during decoding.
      */
     onProgress?: (index: number, percent: number) => void;
     /**
      * Optional custom decoder implementation to inject. When provided, the
      * same instance is shared by all concurrent conversions, so it must be
-     * safe for concurrent `decode()` calls. If not provided, a fresh
-     * default LibheifDecoder is created per item.
+     * safe for concurrent `decode()` calls (see {@link IHeicDecoder}). If not
+     * provided, a fresh default LibheifDecoder is created per item.
      */
     decoder?: IHeicDecoder;
+    /**
+     * Resolve with per-item results instead of rejecting the whole batch on
+     * the first failure: the promise fulfills with `ConvertItemResult[]` in
+     * input order, each item `{ index, ok: true, result }` or
+     * `{ index, ok: false, error }`. All items always run to completion.
+     * Up-front option validation failures still reject normally (a typo is a
+     * caller bug, not an item failure).
+     * @default false
+     */
+    continueOnError?: boolean;
+    /**
+     * Reuse one library-owned `LibheifDecoder` per concurrent runner across
+     * items instead of creating (and WASM-initializing) a fresh instance per
+     * item — amortizes the module load in large batches while preserving the
+     * exclusive-use invariant (an instance is only ever held by one runner,
+     * never decodes concurrently). Ignored when `decoder` is injected.
+     * @default false
+     */
+    reuseDecoders?: boolean;
 }
 
 interface LibheifDecoderOptions {
@@ -90,9 +244,18 @@ interface LibheifDecoderOptions {
     locateFile?: (path: string, prefix: string) => string;
     /**
      * Raw WASM binary buffer. If provided, the library will use this buffer
-     * directly instead of attempting to fetch the WASM file.
+     * directly instead of attempting to fetch the WASM file. Accepts an
+     * `ArrayBuffer` or any `ArrayBufferView` (e.g. a Node.js `Buffer` from
+     * `fs.readFileSync`).
+     */
+    wasmBinary?: ArrayBuffer | ArrayBufferView;
+    /**
+     * Advanced: extra properties merged into the Emscripten module argument
+     * object (e.g. `instantiateWasm` for streaming compilation). Prefer
+     * `locateFile`/`wasmBinary` for the common cases; keys provided here must
+     * not collide with them.
      */
-    wasmBinary?: ArrayBuffer;
+    moduleOverrides?: Record<string, unknown>;
 }
 declare class LibheifDecoder implements IHeicDecoder {
     private options?;
@@ -101,8 +264,15 @@ declare class LibheifDecoder implements IHeicDecoder {
     /**
      * Memoized module-loading promise so concurrent initialize()/decode() calls
      * on the same instance never instantiate (or mutate) the module twice.
+     * Resolves null when a concurrent free() discarded the freshly created
+     * instance (see initGeneration).
      */
     private initPromise;
+    /**
+     * Generation counter for init/free races: a load that finishes after a
+     * concurrent free() must not resurrect module/decoderInstance.
+     */
+    private initGeneration;
     constructor(options?: LibheifDecoderOptions);
     /**
      * Initializes the WebAssembly module and instantiates the HEIC decoder.
@@ -112,18 +282,23 @@ declare class LibheifDecoder implements IHeicDecoder {
     /**
      * Decodes HEIC binary data into raw RGBA pixel data.
      * @param data The HEIC file contents as a Uint8Array.
-     * @param onProgress Optional progress callback.
+     * @param onProgress Optional progress callback (receives a normalized
+     * percentage clamped to 0-100).
      */
     decode(data: Uint8Array, onProgress?: (percent: number) => void): Promise<DecodedImage>;
     /**
      * Cleans up the WebAssembly decoder instance and resources.
-     * Idempotent: safe to call multiple times. After free(), the instance must
-     * be re-initialized (createHeicDecoderModule runs again on the next call).
+     * Idempotent: safe to call multiple times. After free(), the next
+     * initialize() — or decode() directly, which re-initializes transparently
+     * — loads a fresh module.
+     *
+     * free() is also safe to call while initialize() is in flight: a load that
+     * completes after free() discards its fresh instance instead of leaking it.
      */
     free(): void;
 }
 
-interface WorkerConvertOptions extends ConvertOptions {
+interface WorkerConvertOptions extends Omit<ConvertOptions, 'decoder'> {
     /**
      * URL of the worker script that performs the conversion. Should be a
      * compile-time constant (e.g. `new URL('./worker.js', import.meta.url)`
@@ -132,8 +307,8 @@ interface WorkerConvertOptions extends ConvertOptions {
     workerUrl: string | URL;
     /**
      * Maximum time in milliseconds to wait for the worker result before
-     * rejecting with a timeout. Defaults to 60000 (60s). Set to 0 to
-     * disable the timeout.
+     * rejecting with a timeout (queueing for a free worker slot counts toward
+     * this). Defaults to 60000 (60s). Set to 0 to disable the timeout.
      */
     timeoutMs?: number;
     /**
@@ -143,16 +318,44 @@ interface WorkerConvertOptions extends ConvertOptions {
      * @default 'classic'
      */
     workerType?: 'classic' | 'module';
+    /**
+     * Upper bound on simultaneously live workers for this worker script.
+     * Calls beyond the bound queue until a slot frees, which keeps bulk
+     * conversions (`inputs.map(i => convertHeicInWorker(i, …))`) from
+     * exhausting memory or the browser's worker limit.
+     * Defaults to `navigator.hardwareConcurrency` clamped to 1–8.
+     */
+    maxConcurrentWorkers?: number;
+}
+/** Progress message a worker script posts to report decode progress. */
+interface WorkerProgressMessage {
+    type: 'progress';
+    percent: number;
+}
+/** Result message a worker script posts to settle a conversion. */
+interface WorkerResultMessage {
+    type: 'result';
+    ok: boolean;
+    /**
+     * The converted image exactly as `convertHeic` returned it inside the
+     * worker: a Blob, a data-URL string (`output: 'dataUrl'`), or an
+     * ArrayBuffer (`output: 'arrayBuffer'`). The field name `blob` is kept
+     * for protocol compatibility.
+     */
+    blob?: Blob | string | ArrayBuffer;
+    error?: string;
 }
 /**
  * Converts a HEIC image inside a Web Worker so the main thread stays
  * responsive during the (potentially slow) WASM decode.
  *
  * The worker script is user-provided and must handle the following message
- * protocol:
+ * protocol (types are exported as {@link WorkerProgressMessage} and
+ * {@link WorkerResultMessage}):
  *
  * ```js
- * // converter.worker.js
+ * // converter.worker.js — keep in sync with docs/worker.js,
+ * // test/browser/worker.js, and this JSDoc example.
  * import { convertHeic } from '@keeratita/heic-converter';
  *
  * self.onmessage = async (event) => {
@@ -178,15 +381,106 @@ interface WorkerConvertOptions extends ConvertOptions {
  * ```
  *
  * Only `progress` and `result` messages are understood; any other message
- * type is ignored. Use `workerType: 'module'` when the script uses ES
- * module imports (as in the example above); `'classic'` scripts must be
+ * type is ignored (the first unknown type is reported in the timeout
+ * diagnostic). Use `workerType: 'module'` when the script uses ES module
+ * imports (as in the example above); `'classic'` scripts must be
  * pre-bundled, since static ES imports are not supported there.
  *
+ * The `decoder` option is rejected: class instances cannot cross the
+ * worker boundary; the worker creates its own decoder.
+ *
  * @param input HEIC image as a Blob, File, ArrayBuffer, or Uint8Array.
  * @param options Conversion options plus the worker script URL.
- * @returns A Promise resolving to the converted image as a Blob.
+ * @returns The converted image as a Blob, data URL string, or ArrayBuffer
+ *   depending on `options.output` (default Blob).
  */
-declare function convertHeicInWorker(input: HeicInput, options: WorkerConvertOptions): Promise<Blob>;
+declare function convertHeicInWorker<S extends OutputShape = 'blob'>(input: HeicInput, options: WorkerConvertOptions & {
+    output?: S;
+}): Promise<ConvertResult<S>>;
+/**
+ * Options for {@link convertManyInWorker}: the {@link convertHeicInWorker}
+ * worker options plus the batch semantics of `convertMany`.
+ */
+interface WorkerBatchOptions extends Omit<WorkerConvertOptions, 'onProgress'> {
+    /**
+     * Per-item progress callback: receives the 0-based item index and its
+     * progress percentage (normalized 0–100). Fires only for successful items.
+     */
+    onProgress?: (index: number, percent: number) => void;
+    /**
+     * Resolve with per-item results instead of rejecting the batch on the
+     * first failure; all items run to completion (see
+     * `ConvertManyOptions.continueOnError`).
+     * @default false
+     */
+    continueOnError?: boolean;
+}
+/**
+ * Converts multiple HEIC images inside Web Workers, mirroring
+ * {@link convertMany} semantics (input order, bounded concurrency,
+ * `batch_item_failed` aggregation or `continueOnError` per-item results).
+ * Concurrency is bounded by `maxConcurrentWorkers` (default
+ * `navigator.hardwareConcurrency` clamped to 1–8): items queue behind the
+ * worker semaphore, so a large batch never exhausts memory or the browser's
+ * worker limit. Each item runs in its own worker instance via
+ * {@link convertHeicInWorker}, which means `decoder` cannot be injected and
+ * `workerUrl` is required.
+ *
+ * ```ts
+ * const blobs = await convertManyInWorker(heicFiles, {
+ *   workerUrl: new URL('./converter.worker.js', import.meta.url),
+ *   workerType: 'module',
+ *   to: 'webp',
+ *   continueOnError: true, // get per-item results instead of batch rejection
+ * });
+ * ```
+ *
+ * @param inputs HEIC images as Blobs, Files, ArrayBuffers, or Uint8Arrays.
+ * @param options Batch + worker conversion options (see {@link WorkerBatchOptions}).
+ * @returns The converted images in input order, or per-item result entries
+ *   when `continueOnError: true`.
+ */
+declare function convertManyInWorker<S extends OutputShape = 'blob'>(inputs: HeicInput[], options: WorkerBatchOptions & {
+    output?: S;
+    continueOnError: true;
+}): Promise<ConvertItemResult<ConvertResult<S>>[]>;
+declare function convertManyInWorker<S extends OutputShape = 'blob'>(inputs: HeicInput[], options: WorkerBatchOptions & {
+    output?: S;
+    continueOnError?: false;
+}): Promise<ConvertResult<S>[]>;
+declare function convertManyInWorker<S extends OutputShape = 'blob'>(inputs: HeicInput[], options: WorkerBatchOptions & {
+    output?: S;
+    continueOnError: boolean;
+}): Promise<Array<ConvertResult<S> | ConvertItemResult<ConvertResult<S>>>>;
+
+/**
+ * Stable, machine-readable error codes attached to every error the library
+ * throws (as `HeicConverterError.code`). Codes are part of the public API:
+ * they are additive-only and never repurposed, so callers can branch on
+ * `error.code` instead of matching on message strings.
+ */
+type HeicConverterErrorCode = 'invalid_input' | 'invalid_quality' | 'invalid_resize' | 'invalid_format' | 'invalid_crop' | 'invalid_concurrency' | 'decoder_init_failed' | 'decode_failed' | 'progress_callback_failed' | 'render_encode_failed' | 'unsupported_environment' | 'format_unsupported' | 'aborted' | 'worker_unsupported' | 'worker_create_failed' | 'worker_post_failed' | 'worker_failed' | 'worker_timeout' | 'batch_item_failed';
+/**
+ * Error thrown by all first-party code paths. Extends `Error` so existing
+ * `instanceof Error` / message-based handling keeps working; the `code`
+ * (and, for batch failures, `itemIndex`/`itemTotal`/`failedCount`) fields
+ * add a structured discriminator without changing message text.
+ */
+declare class HeicConverterError extends Error {
+    readonly code: HeicConverterErrorCode;
+    /** 0-based index of the failing input. Only set on `batch_item_failed` errors. */
+    readonly itemIndex?: number;
+    /** Total number of inputs in the batch. Only set on `batch_item_failed` errors. */
+    readonly itemTotal?: number;
+    /** How many items failed overall. Only set on `batch_item_failed` errors. */
+    readonly failedCount?: number;
+    constructor(code: HeicConverterErrorCode, message: string, options?: {
+        cause?: unknown;
+        itemIndex?: number;
+        itemTotal?: number;
+        failedCount?: number;
+    });
+}
 
 /**
  * Releases any cached decoder resources.
@@ -196,26 +490,57 @@ declare function convertHeicInWorker(input: HeicInput, options: WorkerConvertOpt
  */
 declare function freeSharedDecoder(): void;
 /**
- * Converts HEIC image data to a standard web format (JPEG, PNG, WebP, or SVG).
+ * Converts HEIC image data to a standard web format (JPEG, PNG, WebP, AVIF,
+ * or SVG).
  *
  * @param input HEIC image as a Blob, File, ArrayBuffer, or Uint8Array.
- * @param options Conversion configuration options.
- * @returns A Promise resolving to the converted image as a Blob.
+ * @param options Conversion configuration options (see {@link ConvertOptions}).
+ * @returns The converted image as a Blob, data URL string, or ArrayBuffer
+ *   depending on `options.output` (default Blob).
+ * @throws HeicConverterError with a machine-readable `code`:
+ *   `invalid_input` (unsupported input type or option value),
+ *   `invalid_quality`, `invalid_resize`, `invalid_crop`,
+ *   `invalid_format` (unknown `to` value), `decoder_init_failed` (WASM
+ *   module could not load), `decode_failed` (invalid/corrupt HEIC),
+ *   `unsupported_environment` (no canvas APIs — e.g. Node.js, where raw RGBA
+ *   decoding via `LibheifDecoder` is the supported path),
+ *   `format_unsupported` (environment cannot encode the format, e.g. AVIF
+ *   in Safari), `aborted` (`options.signal` aborted), or
+ *   `render_encode_failed`.
  */
-declare function convertHeic(input: HeicInput, options?: ConvertOptions): Promise<Blob>;
+declare function convertHeic<S extends OutputShape = 'blob'>(input: HeicInput, options?: ConvertOptions & {
+    output?: S;
+}): Promise<ConvertResult<S>>;
 /**
  * Converts multiple HEIC images to a standard web format.
  *
  * Conversions run with a bounded concurrency (default 4) and results are
- * returned in the same order as the inputs. If any conversion fails, the
- * returned promise rejects as soon as the failure is known (in-flight
- * conversions are allowed to finish in the background) with an error that
- * identifies the failing item index.
+ * returned in the same order as the inputs. By default, if any conversion
+ * fails, the returned promise rejects as soon as the failure is known
+ * (in-flight conversions are allowed to finish in the background) with a
+ * `batch_item_failed` HeicConverterError carrying `itemIndex`, `itemTotal`,
+ * and `failedCount` — a batch is all-or-nothing. With
+ * `options.continueOnError: true` the promise instead fulfills with
+ * per-item `ConvertItemResult` entries and all items run to completion
+ * (a mid-batch abort completes not-yet-started items with `aborted`
+ * entries instead of launching them).
  *
  * @param inputs HEIC images as Blobs, Files, ArrayBuffers, or Uint8Arrays.
- * @param options Batch conversion options.
- * @returns A Promise resolving to the converted images as Blobs, in input order.
+ * @param options Batch conversion options (see {@link ConvertManyOptions}).
+ * @returns The converted images in input order: results array by default,
+ *   or per-item result entries when `continueOnError: true`.
  */
-declare function convertMany(inputs: HeicInput[], options?: ConvertManyOptions): Promise<Blob[]>;
+declare function convertMany<S extends OutputShape = 'blob'>(inputs: HeicInput[], options: ConvertManyOptions & {
+    output?: S;
+    continueOnError: true;
+}): Promise<ConvertItemResult<ConvertResult<S>>[]>;
+declare function convertMany<S extends OutputShape = 'blob'>(inputs: HeicInput[], options?: ConvertManyOptions & {
+    output?: S;
+    continueOnError?: false;
+}): Promise<ConvertResult<S>[]>;
+declare function convertMany<S extends OutputShape = 'blob'>(inputs: HeicInput[], options: ConvertManyOptions & {
+    output?: S;
+    continueOnError: boolean;
+}): Promise<Array<ConvertResult<S> | ConvertItemResult<ConvertResult<S>>>>;
 
-export { type ConvertManyOptions, type ConvertOptions, type DecodedImage, type HeicInput, type IHeicDecoder, type ImageFormat, LibheifDecoder, type LibheifDecoderOptions, type ResizeOptions, type WorkerConvertOptions, convertHeic, convertHeicInWorker, convertMany, freeSharedDecoder };
+export { type ConvertItemResult, type ConvertManyOptions, type ConvertOptions, type ConvertResult, type CropOptions, DEFAULT_QUALITY, type DecodedImage, HeicConverterError, type HeicConverterErrorCode, type HeicInput, type IHeicDecoder, type ImageFormat, LibheifDecoder, type LibheifDecoderOptions, type OutputShape, type ResizeOptions, SUPPORTED_FORMATS, type WorkerBatchOptions, type WorkerConvertOptions, type WorkerProgressMessage, type WorkerResultMessage, convertHeic, convertHeicInWorker, convertMany, convertManyInWorker, freeSharedDecoder };