diff --git "a/vips/vips.d.ts" "b/vips/vips.d.ts"
new file mode 100644--- /dev/null
+++ "b/vips/vips.d.ts"
@@ -0,0 +1,9171 @@
+declare namespace vips {
+
+    // Allow single pixels/images as input.
+    type Array<T> = T | T[];
+
+    type Enum = string | number;
+    type Flag = string | number;
+    type Blob = string | ArrayBuffer | Uint8Array | Uint8ClampedArray | Int8Array;
+    type ArrayConstant = Array<number>;
+    type ArrayImage = Array<Image> | Vector<Image>;
+
+    /**
+     * Get the major, minor or patch version number of the libvips library.
+     * When the flag is omitted, the entire version number is returned as a string.
+     * @param flag 0 to get the major version number, 1 to get minor, 2 to get patch.
+     * @return The version number of libvips.
+     */
+    function version(flag?: number): string | number;
+
+    /**
+     * Returns a string identifying the Emscripten version used for compiling wasm-vips.
+     * @return The version number of Emscripten.
+     */
+    function emscriptenVersion(): string;
+
+    /**
+     * Get detailed information about the installation of libvips.
+     * @return Information about how libvips is configured.
+     */
+    function config(): string;
+
+    /**
+     * Gets or, when a parameter is provided, sets the number of worker threads libvips' should create to
+     * process each image.
+     * @param concurrency The number of worker threads.
+     * @return The number of worker threads libvips uses for image evaluation.
+     */
+    function concurrency(concurrency?: number): void | number;
+
+    /**
+     * Call this to shutdown libvips and the runtime of Emscripten.
+     * This is only needed on Node.js, as the thread pool of
+     * Emscripten prevents the event loop from exiting.
+     */
+    function shutdown(): void;
+
+    /**
+     * A sequence container representing an array that can change in size.
+     */
+    export interface Vector<T> {
+        /**
+         * Adds a new element at the end of the vector, after its current last element.
+         * @param val The value to be appended at the end of the container.
+         */
+        push_back(val: T): void;
+
+        /**
+         * Resizes the container so that it contains n elements.
+         * @param n New size of the container.
+         * @param val The value to initialize the new elements with.
+         */
+        resize(n: number, val: T): void;
+
+        /**
+         * Returns the number of elements in the container.
+         * @return The number of elements in the container.
+         */
+        size(): number;
+
+        /**
+         * Access a specified element with bounds checking.
+         * @param pos Position of the element to return.
+         * @return The requested element or `undefined`.
+         */
+        get(pos: number): T | undefined;
+
+        /**
+         * Update a specified element at a certain position.
+         * @param pos Position of the element to update.
+         * @param val Value to be stored at the specified position.
+         * @return `true` if successfully updated.
+         */
+        set(pos: number, val: T): boolean;
+    }
+
+    /**
+     * A class around libvips' operation cache.
+     */
+    export class Cache {
+        /**
+         * Gets or, when a parameter is provided, sets the maximum number of operations libvips keeps in cache.
+         * @param max Maximum number of operations.
+         * @return The maximum number of operations libvips keeps in cache.
+         */
+        static max(max?: number): void | number;
+
+        /**
+         * Gets or, when a parameter is provided, sets the maximum amount of tracked memory allowed.
+         * @param mem Maximum amount of tracked memory.
+         * @return The maximum amount of tracked memory libvips allows.
+         */
+        static maxMem(mem?: number): void | number;
+
+        /**
+         * Gets or, when a parameter is provided, sets the maximum amount of tracked files allowed.
+         * @param maxFiles Maximum amount of tracked files.
+         * @return The maximum amount of tracked files libvips allows.
+         */
+        static maxFiles(maxFiles?: number): void | number;
+
+        /**
+         * Get the current number of operations in cache.
+         * @return The current number of operations in cache.
+         */
+        static size(): number;
+    }
+
+    /**
+     * A class that provides the statistics of memory usage and opened files.
+     * libvips watches the total amount of live tracked memory and
+     * uses this information to decide when to trim caches.
+     */
+    export class Stats {
+        /**
+         * Get the number of active allocations.
+         * @return The number of active allocations.
+         */
+        static allocations(): number;
+
+        /**
+         * Get the number of bytes currently allocated `vips_malloc()` and friends.
+         * libvips uses this figure to decide when to start dropping cache.
+         * @return The number of bytes currently allocated.
+         */
+        static mem(): number;
+
+        /**
+         * Get the largest number of bytes simultaneously allocated via `vips_tracked_malloc()`.
+         * Handy for estimating max memory requirements for a program.
+         * @return The largest number of currently allocated bytes.
+         */
+        static memHighwater(): number;
+
+        /**
+         * Get the number of open files.
+         * @return The number of open files.
+         */
+        static files(): number;
+    }
+
+    /**
+     * A class for error messages and error handling.
+     */
+    export class Error {
+        /**
+         * Get the error buffer as a string.
+         * @return The error buffer as a string.
+         */
+        static buffer(): string;
+
+        /**
+         * Clear and reset the error buffer.
+         * This is typically called after presenting an error to the user.
+         */
+        static clear(): void;
+    }
+
+    /**
+     * Handy utilities.
+     */
+    export class Utils {
+        /**
+         * Get the GType for a name.
+         * Looks up the GType for a nickname. Types below basename in the type hierarchy are searched.
+         * @param basename Name of base class.
+         * @param nickname Search for a class with this nickname.
+         * @return The GType of the class, or `0` if the class is not found.
+         */
+        static typeFind(basename: string, nickname: string): number;
+
+        /**
+         * Make a temporary file name. The format parameter is something like `"%s.jpg"`
+         * and will be expanded to something like `"/tmp/vips-12-34587.jpg"`.
+         * @param format The filename format.
+         */
+        static tempName(format: string): string;
+    }
+
+    /**
+     * The abstract base Connection class.
+     */
+    export class Connection {
+        /**
+         * Get the filename associated with a connection.
+         */
+        readonly filename: string;
+
+        /**
+         * Make a human-readable name for a connection suitable for error messages.
+         */
+        readonly nick: string;
+    }
+
+    /**
+     * An input connection.
+     */
+    export class Source extends Connection {
+        /**
+         * Make a new source from a file.
+         *
+         * Make a new source that is attached to the named file. For example:
+         * ```js
+         * const source = vips.Source.newFromFile('myfile.jpg');
+         * ```
+         * You can pass this source to (for example) [[Image.newFromSource]].
+         * @param filename The file.
+         * @return A new source.
+         */
+        static newFromFile(filename: string): Source;
+
+        /**
+         * Make a new source from a memory object.
+         *
+         * Make a new source that is attached to the memory object. For example:
+         * ```js
+         * const data = image.writeToBuffer('.jpg');
+         * const source = vips.Source.newFromMemory(data);
+         * ```
+         * You can pass this source to (for example) [[Image.newFromSource]].
+         * @param memory The memory object.
+         * @return A new source.
+         */
+        static newFromMemory(memory: Blob): Source;
+    }
+
+    /**
+     * A source that can be attached to callbacks to implement behavior.
+     */
+    export class SourceCustom extends Source {
+        /**
+         * Attach a read handler.
+         * @param ptr A pointer to an array of bytes where the read content is stored.
+         * @param size The maximum number of bytes to be read.
+         * @return The total number of bytes read into the buffer.
+         */
+        onRead: (ptr: number, size: number) => number;
+
+        /**
+         * Attach a seek handler.
+         * Seek handlers are optional. If you do not set one, your source will be
+         * treated as unseekable and libvips will do extra caching.
+         * @param offset A byte offset relative to the whence parameter.
+         * @param size A value indicating the reference point used to obtain the new position.
+         * @return The new position within the current source.
+         */
+        onSeek: (offset: number, whence: number) => number;
+    }
+
+    /**
+     * An output connection.
+     */
+    export class Target extends Connection {
+        /**
+         * Make a new target to write to a file.
+         *
+         * Make a new target that will write to the named file. For example::
+         * ```js
+         * const target = vips.Target.newToFile('myfile.jpg');
+         * ```
+         * You can pass this target to (for example) [[image.writeToTarget]].
+         * @param filename Write to this this file.
+         * @return A new target.
+         */
+        static newToFile(filename: string): Target;
+
+        /**
+         * Make a new target to write to an area of memory.
+         *
+         * Make a new target that will write to memory. For example:
+         * ```js
+         * const target = vips.Target.newToMemory();
+         * ```
+         * You can pass this target to (for example) [[image.writeToTarget]].
+         *
+         * After writing to the target, fetch the bytes from the target object with [[getBlob]].
+         * @return A new target.
+         */
+        static newToMemory(): Target;
+
+        /**
+         * Fetch the typed array of 8-bit unsigned integer values
+         * from the target object.
+         *
+         * @return A typed array of 8-bit unsigned integer values.
+         */
+        getBlob(): Uint8Array;
+    }
+
+    /**
+     * A target that can be attached to callbacks to implement behavior.
+     */
+    export class TargetCustom extends Target {
+        /**
+         * Attach a write handler.
+         * @param ptr A pointer to an array of bytes which will be written to.
+         * @param length The number of bytes to write.
+         * @return The number of bytes that were written.
+         */
+        onWrite: (ptr: number, size: number) => number;
+
+        /**
+         * Attach a finish handler.
+         * This optional handler is called at the end of write. It should do any
+         * cleaning up, if necessary.
+         */
+        onFinish: () => void;
+    }
+
+    /**
+     * A class to build various interpolators.
+     * For e.g. nearest, bilinear, and some non-linear.
+     */
+    export class Interpolate {
+        /**
+         * Look up an interpolator from a nickname and make one.
+         * @param nickname Nickname for interpolator.
+         * @return An interpolator.
+         */
+        static newFromName(nickname: string): Interpolate;
+    }
+
+    /**
+     * An image class.
+     */
+    export class Image extends ImageAutoGen {
+        /**
+         * Image width in pixels.
+         */
+        readonly width: number;
+
+        /**
+         * Image height in pixels.
+         */
+        readonly height: number;
+
+        /**
+         * Number of bands in image.
+         */
+        readonly bands: number;
+
+        /**
+         * Pixel format in image.
+         */
+        readonly format: string;
+
+        /**
+         * Pixel coding.
+         */
+        readonly coding: string;
+
+        /**
+         * Pixel interpretation.
+         */
+        readonly interpretation: string;
+
+        /**
+         * Horizontal offset of origin.
+         */
+        readonly xoffset: number;
+
+        /**
+         * Vertical offset of origin.
+         */
+        readonly yoffset: number;
+
+        /**
+         * Horizontal resolution in pixels/mm.
+         */
+        readonly xres: number;
+
+        /**
+         * Vertical resolution in pixels/mm.
+         */
+        readonly yres: number;
+
+        /**
+         * Image filename.
+         */
+        readonly filename: string;
+
+        // constructors
+
+        /**
+         * Creates a new image which, when written to, will create a memory image.
+         * @return A new image.
+         */
+        static newMemory(): Image;
+
+        /**
+         * Make a new temporary image.
+         *
+         * Returns an image backed by a temporary file. When written to with
+         * [[write]], a temporary file will be created on disc in the
+         * specified format. When the image is closed, the file will be deleted
+         * automatically.
+         *
+         * The file is created in the temporary directory. This is set with
+         * the environment variable `TMPDIR`. If this is not set, vips will
+         * default to `/tmp`.
+         *
+         * libvips uses `g_mkstemp()` to make the temporary filename. They
+         * generally look something like `"vips-12-EJKJFGH.v"`.
+         * @param format The format for the temp file, defaults to a vips
+         * format file (`"%s.v"`). The `%s` is substituted by the file path.
+         * @return A new image.
+         */
+        static newTempFile(format?: string): Image;
+
+        /**
+         * Load an image from a file.
+         *
+         * This method can load images in any format supported by libvips. The
+         * filename can include load options, for example:
+         * ```js
+         * const image = vips.Image.newFromFile('fred.jpg[shrink=2]');
+         * ```
+         * You can also supply options as keyword arguments, for example:
+         * ```js
+         * const image = vips.Image.newFromFile('fred.jpg', {
+         *     shrink: 2
+         * });
+         * ```
+         * The full set of options available depend upon the load operation that
+         * will be executed. Try something like:
+         * ```bash
+         * $ vips jpegload
+         * ```
+         * at the command-line to see a summary of the available options for the
+         * JPEG loader.
+         *
+         * Loading is fast: only enough of the image is loaded to be able to fill
+         * out the header. Pixels will only be decompressed when they are needed.
+         * @param vipsFilename The file to load the image from, with optional appended arguments.
+         * @param options Optional options that depend on the load operation.
+         * @return A new image.
+         */
+        static newFromFile(vipsFilename: string, options?: {
+            /**
+             * Force open via memory.
+             */
+            memory?: boolean
+            /**
+             * Hint the expected access pattern for the image
+             */
+            access?: Access | Enum
+            /**
+             * Fail on first error.
+             */
+            fail?: boolean
+        }): Image;
+
+        /**
+         * Wrap an image around a memory array.
+         *
+         * Wraps an Image around an area of memory containing a C-style array. For
+         * example, if the `data` memory array contains four bytes with the
+         * values 1, 2, 3, 4, you can make a one-band, 2x2 uchar image from
+         * it like this:
+         * ```js
+         * const data = new Uint8Array([1, 2, 3, 4]);
+         * const image = vips.Image.newFromMemory(data, 2, 2, 1, vips.BandFormat.uchar);
+         * ```
+         * The data object will internally be copied from JavaScript to WASM.
+         *
+         * This method is useful for efficiently transferring images from WebGL into
+         * libvips.
+         *
+         * See [[writeToMemory]] for the opposite operation.
+         * Use [[copy]] to set other image attributes.
+         * @param data A C-style JavaScript array.
+         * @param width Image width in pixels.
+         * @param height Image height in pixels.
+         * @param bands Number of bands.
+         * @param format Band format.
+         * @return A new image.
+         */
+        static newFromMemory(data: Blob, width: number, height: number, bands: number, format: BandFormat): Image;
+
+        /**
+         * Wrap an image around a pointer.
+         *
+         * This behaves exactly as [[newFromMemory]], but the image is
+         * loaded from a pointer rather than from a JavaScript array.
+         * @param ptr A memory address.
+         * @param size Length of memory area.
+         * @param width Image width in pixels.
+         * @param height Image height in pixels.
+         * @param bands Number of bands.
+         * @param format Band format.
+         * @return A new image.
+         */
+        static newFromMemory(ptr: number, size: number, width: number, height: number, bands: number, format: BandFormat): Image;
+
+        /**
+         * Load a formatted image from memory.
+         *
+         * This behaves exactly as [[newFromFile]], but the image is
+         * loaded from the memory object rather than from a file. The
+         * memory object can be a string or buffer.
+         * @param data The memory object to load the image from.
+         * @param strOptions Load options as a string.
+         * @param options Optional options that depend on the load operation.
+         * @return A new image.
+         */
+        static newFromBuffer(data: Blob, strOptions?: string, options?: {
+            /**
+             * Hint the expected access pattern for the image
+             */
+            access?: Access | Enum
+            /**
+             * Fail on first error.
+             */
+            fail?: boolean
+        }): Image;
+
+        /**
+         * Load a formatted image from a source.
+         *
+         * This behaves exactly as [[newFromFile]], but the image is
+         * loaded from a source rather than from a file.
+         * @param source The source to load the image from.
+         * @param strOptions Load options as a string.
+         * @param options Optional options that depend on the load operation.
+         * @return A new image.
+         */
+        static newFromSource(source: Source, strOptions?: string, options?: {
+            /**
+             * Hint the expected access pattern for the image
+             */
+            access?: Access | Enum
+            /**
+             * Fail on first error.
+             */
+            fail?: boolean
+        }): Image;
+
+        /**
+         * Create an image from a 1D array.
+         *
+         * A new one-band image with [[BandFormat.double]] pixels is
+         * created from the array. These image are useful with the libvips
+         * convolution operator [[conv]].
+         * @param width Image width.
+         * @param height Image height.
+         * @param array Create the image from these values.
+         * @return A new image.
+         */
+        static newMatrix(width: number, height: number, array?: ArrayConstant): Image;
+
+        /**
+         * Create an image from a 2D array.
+         *
+         * A new one-band image with [[BandFormat.double]] pixels is
+         * created from the array. These image are useful with the libvips
+         * convolution operator [[conv]].
+         * @param array Create the image from these values.
+         * @param scale Default to 1.0. What to divide each pixel by after
+         * convolution. Useful for integer convolution masks.
+         * @param offset Default to 0.0. What to subtract from each pixel
+         * after convolution. Useful for integer convolution masks.
+         * @return A new image.
+         */
+        static newFromArray(array: ArrayConstant, scale?: number, offset?: number): Image;
+
+        /**
+         * Make a new image from an existing one.
+         *
+         * A new image is created which has the same size, format, interpretation
+         * and resolution as itself, but with every pixel set to `value`.
+         * @param value The value for the pixels. Use a single number to make a
+         * one-band image; use an array constant to make a many-band image.
+         * @return A new image.
+         */
+        newFromImage(value: ArrayConstant): Image;
+
+        /**
+         * Copy an image to memory.
+         *
+         * A large area of memory is allocated, the image is rendered to that
+         * memory area, and a new image is returned which wraps that large memory
+         * area.
+         * @return A new image.
+         */
+        copyMemory(): Image;
+
+        // writers
+
+        /**
+         * Write an image to another image.
+         *
+         * This function writes itself to another image. Use something like
+         * [[newTempFile]] to make an image that can be written to.
+         * @param other The image to write to.
+         * @return A new image.
+         */
+        write(other: Image): Image;
+
+        /**
+         * Write an image to a file.
+         *
+         * This method can save images in any format supported by libvips. The format
+         * is selected from the filename suffix. The filename can include embedded
+         * save options, see [[newFromFile]].
+         *
+         * For example:
+         * ```js
+         * image.writeToFile('fred.jpg[Q=95]');
+         * ```
+         * You can also supply options as keyword arguments, for example:
+         * ```js
+         * image.writeToFile('.fred.jpg', {
+         *     Q: 95
+         * });
+         * ```
+         * The full set of options available depend upon the save operation that
+         * will be executed. Try something like:
+         * ```bash
+         * $ vips jpegsave
+         * ```
+         * at the command-line to see a summary of the available options for the
+         * JPEG saver.
+         * @param vipsFilename The file to save the image to, with optional appended arguments.
+         * @param options Optional options that depend on the save operation.
+         */
+        writeToFile(vipsFilename: string, options?: {}): void;
+
+        /**
+         * Write an image to a typed array of 8-bit unsigned integer values.
+         *
+         * This method can save images in any format supported by libvips. The format
+         * is selected from the suffix in the format string. This can include
+         * embedded save options, see [[newFromFile]].
+         *
+         * For example:
+         * ```js
+         * const data = image.writeToBuffer('.jpg[Q=95]');
+         * ```
+         * You can also supply options as keyword arguments, for example:
+         * ```js
+         * const data = image.writeToBuffer('.jpg', {
+         *     Q: 85
+         * });
+         * ```
+         * The full set of options available depend upon the load operation that
+         * will be executed. Try something like:
+         * ```bash
+         * $ vips jpegsave_buffer
+         * ```
+         * at the command-line to see a summary of the available options for the
+         * JPEG saver.
+         * @param formatString The suffix, plus any string-form arguments.
+         * @param options Optional options that depend on the save operation.
+         * @return A typed array of 8-bit unsigned integer values.
+         */
+        writeToBuffer(formatString: string, options?: {}): Uint8Array;
+
+        /**
+         * Write an image to a target.
+         *
+         * This behaves exactly as [[writeToFile]], but the image is
+         * written to a target rather than a file.
+         * @param target Write to this target.
+         * @param formatString The suffix, plus any string-form arguments.
+         * @param options Optional options that depend on the save operation.
+         */
+        writeToTarget(target: Target, formatString: string, options?: {}): void;
+
+        /**
+         * Write the image to a large memory array.
+         *
+         * A large area of memory is allocated, the image is rendered to that
+         * memory array, and the array is returned as a typed array.
+         *
+         * For example, if you have a 2x2 uchar image containing the bytes 1, 2,
+         * 3, 4, read left-to-right, top-to-bottom, then:
+         * ```js
+         * const array = Uint8Array.of(1, 2, 3, 4);
+         * const im = vips.Image.newFromMemory(array, 2, 2, 1, 'uchar');
+         * const buf = im.writeToMemory();
+         * ```
+         * will return a four byte typed array containing the values 1, 2, 3, 4.
+         * @return A typed array of 8-bit unsigned integer values.
+         */
+        writeToMemory(): Uint8Array;
+
+        // get/set metadata
+
+        /**
+         * Set an integer on an image as metadata.
+         * @param name The name of the piece of metadata to set the value of.
+         * @param value The metadata value.
+         */
+        setInt(name: string, value: number): void;
+
+        /**
+         * Set an integer array on an image as metadata.
+         * @param name The name of the piece of metadata to set the value of.
+         * @param value The metadata value.
+         */
+        setArrayInt(name: string, value: ArrayConstant): void;
+
+        /**
+         * Set an double array on an image as metadata.
+         * @param name The name of the piece of metadata to set the value of.
+         * @param value The metadata value.
+         */
+        setArrayDouble(name: string, value: ArrayConstant): void;
+
+        /**
+         * Set an double on an image as metadata.
+         * @param name The name of the piece of metadata to set the value of.
+         * @param value The metadata value.
+         */
+        setDouble(name: string, value: number): void;
+
+        /**
+         * Set an string on an image as metadata.
+         * @param name The name of the piece of metadata to set the value of.
+         * @param value The metadata value.
+         */
+        setString(name: string, value: string): void;
+
+        /**
+         * Set an blob on an image as metadata.
+         * The value will internally be copied from JavaScript to WASM.
+         * @param name The name of the piece of metadata to set the value of.
+         * @param value The metadata value.
+         */
+        setBlob(name: string, value: Blob): void;
+
+        /**
+         * Set an blob pointer on an image as metadata.
+         * @param name The name of the piece of metadata to set the value of.
+         * @param ptr The metadata value as memory address.
+         * @param size Length of blob.
+         */
+        setBlob(name: string, ptr: number, size: number): void;
+
+        /**
+         * Get the GType of an item of metadata.
+         * Fetch the GType of a piece of metadata, or 0 if the named item does not exist.
+         * @param name The name of the piece of metadata to get the type of.
+         * @return The GType, or `0` if not found.
+         */
+        getTypeof(name: string): number;
+
+        /**
+         * Get an integer from an image.
+         * @param name The name of the piece of metadata to get.
+         * @return The metadata item as an integer.
+         */
+        getInt(name: string): number;
+
+        /**
+         * Get an integer array from an image.
+         * @param name The name of the piece of metadata to get.
+         * @return The metadata item as an integer array.
+         */
+        getArrayInt(name: string): number[];
+
+        /**
+         * Get an double array from an image.
+         * @param name The name of the piece of metadata to get.
+         * @return The metadata item as an double array.
+         */
+        getArrayDouble(name: string): number[];
+
+        /**
+         * Get an double from an image.
+         * @param name The name of the piece of metadata to get.
+         * @return The metadata item as an double.
+         */
+        getDouble(name: string): number;
+
+        /**
+         * Get an string from an image.
+         * @param name The name of the piece of metadata to get.
+         * @return The metadata item as an string.
+         */
+        getString(name: string): string;
+
+        /**
+         * Get an blob from an image.
+         * @param name The name of the piece of metadata to get.
+         * @return The metadata item as an typed array of 8-bit unsigned integer values.
+         */
+        getBlob(name: string): Uint8Array;
+
+        /**
+         * Get a list of all the metadata fields on an image.
+         * @return All metadata fields as string vector.
+         */
+        getFields(): Vector<string>;
+
+        /**
+         * Remove an item of metadata.
+         * @param name The name of the piece of metadata to remove.
+         * @return `true` if successfully removed.
+         */
+        remove(name: string): string;
+
+        // handwritten functions
+
+        /**
+         * Does this image have an alpha channel?
+         * @return `true` if this image has an alpha channel.
+         */
+        hasAlpha(): boolean;
+
+        /**
+         * Sets the `delete_on_close` flag for the image.
+         * If this flag is set, when image is finalized, the filename held in
+         * [[image.filename]] at the time of this call is deleted.
+         * This function is clearly extremely dangerous, use with great caution.
+         */
+        setDeleteOnClose(flag: boolean): void;
+
+        /**
+         * Search an image for non-edge areas.
+         * @param options Optional options.
+         * @return The bounding box of the non-background area.
+         */
+        findTrim(options?: {
+            /**
+             * Object threshold.
+             */
+            threshold?: number
+            /**
+             * Color for background pixels.
+             */
+            background?: ArrayConstant
+        }): {
+            /**
+             * Output left edge.
+             */
+            left: number
+
+            /**
+             * Output top edge.
+             */
+            top: number
+
+            /**
+             * Output width.
+             */
+            width: number
+
+            /**
+             * Output width.
+             */
+            height: number
+        };
+
+        /**
+         * Find image profiles.
+         * @return First non-zero pixel in column/row.
+         */
+        profile(): {
+            /**
+             * Distances from top edge.
+             */
+            columns: Image
+
+            /**
+             * Distances from left edge.
+             */
+            rows: Image
+        };
+
+        /**
+         * Find image projections.
+         * @return Sums of columns/rows.
+         */
+        project(): {
+            /**
+             * Sums of columns.
+             */
+            columns: Image
+
+            /**
+             * Sums of rows.
+             */
+            rows: Image
+        };
+
+        /**
+         * Split an n-band image into n separate images.
+         * @return Vector of output images.
+         */
+        bandsplit(): Vector<Image>;
+
+        /**
+         * Append a set of images or constants bandwise
+         * @param _in Array of input images.
+         * @return Output image.
+         */
+        bandjoin(_in: ArrayImage | ArrayConstant): Image;
+
+        /**
+         * Band-wise rank filter a set of images or constants.
+         * @param _in Array of input images.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        bandrank(_in: ArrayImage | ArrayConstant, options?: {
+            /**
+             * Select this band element from sorted list.
+             */
+            index?: number
+        }): Image;
+
+        /**
+         * Composite a set of images with a set of blend modes.
+         * @param _in Images to composite.
+         * @param mode Blend modes to use.
+         * @param options Optional options.
+         * @return Blended image.
+         */
+        static composite(_in: ArrayImage, mode: Array<Enum>, options?: {
+            /**
+             * Array of x coordinates to join at.
+             */
+            x?: ArrayConstant
+            /**
+             * Array of y coordinates to join at.
+             */
+            y?: ArrayConstant
+            /**
+             * Composite images in this colour space.
+             */
+            compositing_space?: Interpretation | Enum
+            /**
+             * Images have premultiplied alpha.
+             */
+            premultiplied?: boolean
+        }): Image;
+
+        /**
+         * Composite a set of images with a set of blend modes.
+         * @param overlay Images to composite.
+         * @param mode Blend modes to use.
+         * @param options Optional options.
+         * @return Blended image.
+         */
+        composite(overlay: ArrayImage, mode: Array<Enum>, options?: {
+            /**
+             * Array of x coordinates to join at.
+             */
+            x?: ArrayConstant
+            /**
+             * Array of y coordinates to join at.
+             */
+            y?: ArrayConstant
+            /**
+             * Composite images in this colour space.
+             */
+            compositing_space?: Interpretation | Enum
+            /**
+             * Images have premultiplied alpha.
+             */
+            premultiplied?: boolean
+        }): Image;
+
+        /**
+         * Return the coordinates of the image maximum.
+         * @return Array of output values.
+         */
+        maxPos(): number[];
+
+        /**
+         * Return the coordinates of the image minimum.
+         * @return Array of output values.
+         */
+        minPos(): number[];
+
+        /**
+         * Flip an image horizontally.
+         * @return Output image.
+         */
+        flipHor(): Image;
+
+        /**
+         * Flip an image vertically.
+         * @return Output image.
+         */
+        flipVer(): Image;
+
+        /**
+         * Rotate an image 90 degrees clockwise.
+         * @return Output image.
+         */
+        rot90(): Image;
+
+        /**
+         * Rotate an image 180 degrees.
+         * @return Output image.
+         */
+        rot180(): Image;
+
+        /**
+         * Rotate an image 270 degrees clockwise.
+         * @return Output image.
+         */
+        rot270(): Image;
+
+        /**
+         * size x size median filter.
+         * @param size The size of the median filter, defaults to 3.
+         * @return Output image.
+         */
+        median(size?: number): Image;
+
+        /**
+         * Return the largest integral value not greater than the argument.
+         * @return Output image.
+         */
+        floor(): Image;
+
+        /**
+         * Return the smallest integral value not less than the argument.
+         * @return Output image.
+         */
+        ceil(): Image;
+
+        /**
+         * Return the nearest integral value.
+         * @return Output image.
+         */
+        rint(): Image;
+
+        /**
+         * AND image bands together.
+         * @return Output image.
+         */
+        bandand(): Image;
+
+        /**
+         * OR image bands together.
+         * @return Output image.
+         */
+        bandor(): Image;
+
+        /**
+         * EOR image bands together.
+         * @return Output image.
+         */
+        bandeor(): Image;
+
+        /**
+         * Return the real part of a complex image.
+         * @return Output image.
+         */
+        real(): Image;
+
+        /**
+         * Return the imaginary part of a complex image.
+         * @return Output image.
+         */
+        imag(): Image;
+
+        /**
+         * Return an image converted to polar coordinates.
+         * @return Output image.
+         */
+        polar(): Image;
+
+        /**
+         * Return an image converted to rectangular coordinates.
+         * @return Output image.
+         */
+        rect(): Image;
+
+        /**
+         * Return the complex conjugate of an image.
+         * @return Output image.
+         */
+        conj(): Image;
+
+        /**
+         * Return the sine of an image in degrees.
+         * @return Output image.
+         */
+        sin(): Image;
+
+        /**
+         * Return the cosine of an image in degrees.
+         * @return Output image.
+         */
+        cos(): Image;
+
+        /**
+         * Return the tangent of an image in degrees.
+         * @return Output image.
+         */
+        tan(): Image;
+
+        /**
+         * Return the inverse sine of an image in degrees.
+         * @return Output image.
+         */
+        asin(): Image;
+
+        /**
+         * Return the inverse cosine of an image in degrees.
+         * @return Output image.
+         */
+        acos(): Image;
+
+        /**
+         * Return the inverse tangent of an image in degrees.
+         * @return Output image.
+         */
+        atan(): Image;
+
+        /**
+         * Return the hyperbolic sine of an image in radians.
+         * @return Output image.
+         */
+        sinh(): Image;
+
+        /**
+         * Return the hyperbolic cosine of an image in radians.
+         * @return Output image.
+         */
+        cosh(): Image;
+
+        /**
+         * Return the hyperbolic tangent of an image in radians.
+         * @return Output image.
+         */
+        tanh(): Image;
+
+        /**
+         * Return the inverse hyperbolic sine of an image in radians.
+         * @return Output image.
+         */
+        asinh(): Image;
+
+        /**
+         * Return the inverse hyperbolic cosine of an image in radians.
+         * @return Output image.
+         */
+        acosh(): Image;
+
+        /**
+         * Return the inverse hyperbolic tangent of an image in radians.
+         * @return Output image.
+         */
+        atanh(): Image;
+
+        /**
+         * Return the natural log of an image.
+         * @return Output image.
+         */
+        log(): Image;
+
+        /**
+         * Return the log base 10 of an image.
+         * @return Output image.
+         */
+        log10(): Image;
+
+        /**
+         * Return e ** pixel.
+         * @return Output image.
+         */
+        exp(): Image;
+
+        /**
+         * Return 10 ** pixel.
+         * @return Output image.
+         */
+        exp10(): Image;
+
+        /**
+         * Erode with a structuring element.
+         * @param mask Input matrix image.
+         * @return Output image.
+         */
+        erode(mask: Image | ArrayConstant): Image;
+
+        /**
+         * Dilate with a structuring element.
+         * @param mask Input matrix image.
+         * @return Output image.
+         */
+        dilate(mask: Image | ArrayConstant): Image;
+
+        /**
+         * Raise to power of an image or constant.
+         * @param right To the power of this.
+         * @return Output image.
+         */
+        pow(right: Image | ArrayConstant): Image;
+
+        /**
+         * Raise to power of an image, but with the arguments reversed.
+         * @param right To the power of this.
+         * @return Output image.
+         */
+        wop(right: Image | ArrayConstant): Image;
+
+        /**
+         * Arc tangent of an image or constant.
+         * @param right Divisor parameter.
+         * @return Output image.
+         */
+        atan2(right: Image | ArrayConstant): Image;
+
+        /**
+         * Performs a bitwise left shift operation (<<).
+         * @param right Right operand.
+         * @return Output image.
+         */
+        lshift(right: Image | ArrayConstant): Image;
+
+        /**
+         * Performs a bitwise right shift operation (>>).
+         * @param right Right operand.
+         * @return Output image.
+         */
+        rshift(right: Image | ArrayConstant): Image;
+
+        /**
+         * Performs a bitwise AND operation (&).
+         * @param right Right operand.
+         * @return Output image.
+         */
+        and(right: Image | ArrayConstant): Image;
+
+        /**
+         * Performs a bitwise OR operation (|) .
+         * @param right Right operand.
+         * @return Output image.
+         */
+        or(right: Image | ArrayConstant): Image;
+
+        /**
+         * Performs a bitwise exclusive-OR operation (^).
+         * @param right Right operand.
+         * @return Output image.
+         */
+        eor(right: Image | ArrayConstant): Image;
+
+        /**
+         * Performs a relational greater than operation (>).
+         * @param right Right operand.
+         * @return Output image.
+         */
+        more(right: Image | ArrayConstant): Image;
+
+        /**
+         * Performs a relational greater than or equal operation (>=).
+         * @param right Right operand.
+         * @return Output image.
+         */
+        moreEq(right: Image | ArrayConstant): Image;
+
+        /**
+         * Performs a relational less than operation (<).
+         * @param right Right operand.
+         * @return Output image.
+         */
+        less(right: Image | ArrayConstant): Image;
+
+        /**
+         * Performs a relational less than or equal operation (<=).
+         * @param right Right operand.
+         * @return Output image.
+         */
+        lessEq(right: Image | ArrayConstant): Image;
+
+        /**
+         * Performs a relational equality operation (==).
+         * @param right Right operand.
+         * @return Output image.
+         */
+        equal(right: Image | ArrayConstant): Image;
+
+        /**
+         * Performs a relational inequality operation (!=).
+         * @param right Right operand.
+         * @return Output image.
+         */
+        notEq(right: Image | ArrayConstant): Image;
+    }
+
+    /**
+     * The format used for each band element.
+     * 
+     * Each corresponds to a native C type for the current machine. For example,
+     * #VIPS_FORMAT_USHORT is <type>unsigned short</type>.
+     */
+    export enum BandFormat {
+        /**
+         * Unsigned char format
+         */
+        uchar = 'uchar',
+        /**
+         * Char format
+         */
+        char = 'char',
+        /**
+         * Unsigned short format
+         */
+        ushort = 'ushort',
+        /**
+         * Short format
+         */
+        short = 'short',
+        /**
+         * Unsigned int format
+         */
+        uint = 'uint',
+        /**
+         * Int format
+         */
+        int = 'int',
+        /**
+         * Float format
+         */
+        float = 'float',
+        /**
+         * Complex (two floats) format
+         */
+        complex = 'complex',
+        /**
+         * Double float format
+         */
+        double = 'double',
+        /**
+         * Double complex (two double) format
+         */
+        dpcomplex = 'dpcomplex'
+    }
+
+    /**
+     * The various Porter-Duff and PDF blend modes. See vips_composite(),
+     * for example.
+     * 
+     * The Cairo docs have a nice explanation of all the blend modes:
+     * 
+     * https://www.cairographics.org/operators
+     * 
+     * The non-separable modes are not implemented.
+     */
+    export enum BlendMode {
+        /**
+         * Where the second object is drawn, the first is removed
+         */
+        clear = 'clear',
+        /**
+         * The second object is drawn as if nothing were below
+         */
+        source = 'source',
+        /**
+         * The image shows what you would expect if you held two semi-transparent slides on top of each other
+         */
+        over = 'over',
+        /**
+         * The first object is removed completely, the second is only drawn where the first was
+         */
+        in = 'in',
+        /**
+         * The second is drawn only where the first isn't
+         */
+        out = 'out',
+        /**
+         * This leaves the first object mostly intact, but mixes both objects in the overlapping area
+         */
+        atop = 'atop',
+        /**
+         * Leaves the first object untouched, the second is discarded completely
+         */
+        dest = 'dest',
+        /**
+         * Like OVER, but swaps the arguments
+         */
+        dest_over = 'dest-over',
+        /**
+         * Like IN, but swaps the arguments
+         */
+        dest_in = 'dest-in',
+        /**
+         * Like OUT, but swaps the arguments
+         */
+        dest_out = 'dest-out',
+        /**
+         * Like ATOP, but swaps the arguments
+         */
+        dest_atop = 'dest-atop',
+        /**
+         * Something like a difference operator
+         */
+        xor = 'xor',
+        /**
+         * A bit like adding the two images
+         */
+        add = 'add',
+        /**
+         * A bit like the darker of the two
+         */
+        saturate = 'saturate',
+        /**
+         * At least as dark as the darker of the two inputs
+         */
+        multiply = 'multiply',
+        /**
+         * At least as light as the lighter of the inputs
+         */
+        screen = 'screen',
+        /**
+         * Multiplies or screens colors, depending on the lightness
+         */
+        overlay = 'overlay',
+        /**
+         * The darker of each component
+         */
+        darken = 'darken',
+        /**
+         * The lighter of each component
+         */
+        lighten = 'lighten',
+        /**
+         * Brighten first by a factor second
+         */
+        colour_dodge = 'colour-dodge',
+        /**
+         * Darken first by a factor of second
+         */
+        colour_burn = 'colour-burn',
+        /**
+         * Multiply or screen, depending on lightness
+         */
+        hard_light = 'hard-light',
+        /**
+         * Darken or lighten, depending on lightness
+         */
+        soft_light = 'soft-light',
+        /**
+         * Difference of the two
+         */
+        difference = 'difference',
+        /**
+         * Somewhat like DIFFERENCE, but lower-contrast
+         */
+        exclusion = 'exclusion'
+    }
+
+    /**
+     * How pixels are coded.
+     * 
+     * Normally, pixels are uncoded and can be manipulated as you would expect.
+     * However some file formats code pixels for compression, and sometimes it's
+     * useful to be able to manipulate images in the coded format.
+     * 
+     * The gaps in the numbering are historical and must be maintained. Allocate
+     * new numbers from the end.
+     */
+    export enum Coding {
+        /**
+         * Pixels are not coded
+         */
+        none = 'none',
+        /**
+         * Pixels encode 3 float CIELAB values as 4 uchar
+         */
+        labq = 'labq',
+        /**
+         * Pixels encode 3 float RGB as 4 uchar (Radiance coding)
+         */
+        rad = 'rad'
+    }
+
+    /**
+     * How the values in an image should be interpreted. For example, a
+     * three-band float image of type #VIPS_INTERPRETATION_LAB should have its
+     * pixels interpreted as coordinates in CIE Lab space.
+     * 
+     * RGB and sRGB are treated in the same way. Use the colourspace functions if
+     * you want some other behaviour.
+     * 
+     * The gaps in numbering are historical and must be maintained. Allocate
+     * new numbers from the end.
+     */
+    export enum Interpretation {
+        /**
+         * Generic many-band image
+         */
+        multiband = 'multiband',
+        /**
+         * Some kind of single-band image
+         */
+        b_w = 'b-w',
+        /**
+         * A 1D image, eg. histogram or lookup table
+         */
+        histogram = 'histogram',
+        /**
+         * The first three bands are CIE XYZ
+         */
+        xyz = 'xyz',
+        /**
+         * Pixels are in CIE Lab space
+         */
+        lab = 'lab',
+        /**
+         * The first four bands are in CMYK space
+         */
+        cmyk = 'cmyk',
+        /**
+         * Implies #VIPS_CODING_LABQ
+         */
+        labq = 'labq',
+        /**
+         * Generic RGB space
+         */
+        rgb = 'rgb',
+        /**
+         * A uniform colourspace based on CMC(1:1)
+         */
+        cmc = 'cmc',
+        /**
+         * Pixels are in CIE LCh space
+         */
+        lch = 'lch',
+        /**
+         * CIE LAB coded as three signed 16-bit values
+         */
+        labs = 'labs',
+        /**
+         * Pixels are sRGB
+         */
+        srgb = 'srgb',
+        /**
+         * Pixels are CIE Yxy
+         */
+        yxy = 'yxy',
+        /**
+         * Image is in fourier space
+         */
+        fourier = 'fourier',
+        /**
+         * Generic 16-bit RGB
+         */
+        rgb16 = 'rgb16',
+        /**
+         * Generic 16-bit mono
+         */
+        grey16 = 'grey16',
+        /**
+         * A matrix
+         */
+        matrix = 'matrix',
+        /**
+         * Pixels are scRGB
+         */
+        scrgb = 'scrgb',
+        /**
+         * Pixels are HSV
+         */
+        hsv = 'hsv'
+    }
+
+    /**
+     * See vips_image_pipelinev(). Operations can hint to the VIPS image IO
+     * system about the kind of demand geometry they prefer.
+     * 
+     * These demand styles are given below in order of increasing
+     * restrictiveness.  When demanding output from a pipeline,
+     * vips_image_generate()
+     * will use the most restrictive of the styles requested by the operations
+     * in the pipeline.
+     * 
+     * #VIPS_DEMAND_STYLE_THINSTRIP --- This operation would like to output strips
+     * the width of the image and a few pels high. This is option suitable for
+     * point-to-point operations, such as those in the arithmetic package.
+     * 
+     * This option is only efficient for cases where each output pel depends
+     * upon the pel in the corresponding position in the input image.
+     * 
+     * #VIPS_DEMAND_STYLE_FATSTRIP --- This operation would like to output strips
+     * the width of the image and as high as possible. This option is suitable
+     * for area operations which do not violently transform coordinates, such
+     * as vips_conv().
+     * 
+     * #VIPS_DEMAND_STYLE_SMALLTILE --- This is the most general demand format.
+     * Output is demanded in small (around 100x100 pel) sections. This style works
+     * reasonably efficiently, even for bizzare operations like 45 degree rotate.
+     * 
+     * #VIPS_DEMAND_STYLE_ANY --- This image is not being demand-read from a disc
+     * file (even indirectly) so any demand style is OK. It's used for things like
+     * vips_black() where the pixels are calculated.
+     * 
+     * See also: vips_image_pipelinev().
+     */
+    export enum DemandStyle {
+        /**
+         * Demand in small (typically 64x64 pixel) tiles
+         */
+        smalltile = 'smalltile',
+        /**
+         * Demand in fat (typically 10 pixel high) strips
+         */
+        fatstrip = 'fatstrip',
+        /**
+         * Demand in thin (typically 1 pixel high) strips
+         */
+        thinstrip = 'thinstrip'
+    }
+
+    /**
+     * See also: vips_relational().
+     */
+    export enum OperationRelational {
+        /**
+         * ==
+         */
+        equal = 'equal',
+        /**
+         * !=
+         */
+        noteq = 'noteq',
+        /**
+         * <
+         */
+        less = 'less',
+        /**
+         * <=
+         */
+        lesseq = 'lesseq',
+        /**
+         * >
+         */
+        more = 'more',
+        /**
+         * >=
+         */
+        moreeq = 'moreeq'
+    }
+
+    /**
+     * See also: vips_boolean().
+     */
+    export enum OperationBoolean {
+        /**
+         * &
+         */
+        and = 'and',
+        /**
+         * |
+         */
+        or = 'or',
+        /**
+         * ^
+         */
+        eor = 'eor',
+        /**
+         * >>
+         */
+        lshift = 'lshift',
+        /**
+         * <<
+         */
+        rshift = 'rshift'
+    }
+
+    /**
+     * See also: vips_math().
+     */
+    export enum OperationMath2 {
+        /**
+         * Pow( left, right )
+         */
+        pow = 'pow',
+        /**
+         * Pow( right, left )
+         */
+        wop = 'wop',
+        /**
+         * Atan2( left, right )
+         */
+        atan2 = 'atan2'
+    }
+
+    /**
+     * See also: vips_complex2().
+     */
+    export enum OperationComplex2 {
+        /**
+         * Convert to polar coordinates
+         */
+        cross_phase = 'cross-phase'
+    }
+
+    /**
+     * See also: vips_math().
+     */
+    export enum OperationMath {
+        /**
+         * Sin(), angles in degrees
+         */
+        sin = 'sin',
+        /**
+         * Cos(), angles in degrees
+         */
+        cos = 'cos',
+        /**
+         * Tan(), angles in degrees
+         */
+        tan = 'tan',
+        /**
+         * Asin(), angles in degrees
+         */
+        asin = 'asin',
+        /**
+         * Acos(), angles in degrees
+         */
+        acos = 'acos',
+        /**
+         * Atan(), angles in degrees
+         */
+        atan = 'atan',
+        /**
+         * Log base e
+         */
+        log = 'log',
+        /**
+         * Log base 10
+         */
+        log10 = 'log10',
+        /**
+         * E to the something
+         */
+        exp = 'exp',
+        /**
+         * 10 to the something
+         */
+        exp10 = 'exp10',
+        /**
+         * Sinh(), angles in radians
+         */
+        sinh = 'sinh',
+        /**
+         * Cosh(), angles in radians
+         */
+        cosh = 'cosh',
+        /**
+         * Tanh(), angles in radians
+         */
+        tanh = 'tanh',
+        /**
+         * Asinh(), angles in radians
+         */
+        asinh = 'asinh',
+        /**
+         * Acosh(), angles in radians
+         */
+        acosh = 'acosh',
+        /**
+         * Atanh(), angles in radians
+         */
+        atanh = 'atanh'
+    }
+
+    /**
+     * See also: vips_round().
+     */
+    export enum OperationRound {
+        /**
+         * Round to nearest
+         */
+        rint = 'rint',
+        /**
+         * The smallest integral value not less than
+         */
+        ceil = 'ceil',
+        /**
+         * Largest integral value not greater than
+         */
+        floor = 'floor'
+    }
+
+    /**
+     * See also: vips_complex().
+     */
+    export enum OperationComplex {
+        /**
+         * Convert to polar coordinates
+         */
+        polar = 'polar',
+        /**
+         * Convert to rectangular coordinates
+         */
+        rect = 'rect',
+        /**
+         * Complex conjugate
+         */
+        conj = 'conj'
+    }
+
+    /**
+     * See also: vips_complexget().
+     */
+    export enum OperationComplexget {
+        /**
+         * Get real component
+         */
+        real = 'real',
+        /**
+         * Get imaginary component
+         */
+        imag = 'imag'
+    }
+
+    /**
+     * How to combine values. See vips_compass(), for example.
+     */
+    export enum Combine {
+        /**
+         * Take the maximum of the possible values
+         */
+        max = 'max',
+        /**
+         * Sum all the values
+         */
+        sum = 'sum',
+        /**
+         * Take the minimum value
+         */
+        min = 'min'
+    }
+
+    /**
+     * The type of access an operation has to supply. See vips_tilecache()
+     * and #VipsForeign.
+     * 
+     * @VIPS_ACCESS_RANDOM means requests can come in any order.
+     * 
+     * @VIPS_ACCESS_SEQUENTIAL means requests will be top-to-bottom, but with some
+     * amount of buffering behind the read point for small non-local accesses.
+     */
+    export enum Access {
+        /**
+         * Can read anywhere
+         */
+        random = 'random',
+        /**
+         * Top-to-bottom reading only, but with a small buffer
+         */
+        sequential = 'sequential',
+        sequential_unbuffered = 'sequential-unbuffered'
+    }
+
+    /**
+     * See vips_embed(), vips_conv(), vips_affine() and so on.
+     * 
+     * When the edges of an image are extended, you can specify
+     * how you want the extension done.
+     * 
+     * #VIPS_EXTEND_BLACK --- new pixels are black, ie. all bits are zero.
+     * 
+     * #VIPS_EXTEND_COPY --- each new pixel takes the value of the nearest edge
+     * pixel
+     * 
+     * #VIPS_EXTEND_REPEAT --- the image is tiled to fill the new area
+     * 
+     * #VIPS_EXTEND_MIRROR --- the image is reflected and tiled to reduce hash
+     * edges
+     * 
+     * #VIPS_EXTEND_WHITE --- new pixels are white, ie. all bits are set
+     * 
+     * #VIPS_EXTEND_BACKGROUND --- colour set from the @background property
+     * 
+     * We have to specify the exact value of each enum member since we have to
+     * keep these frozen for back compat with vips7.
+     * 
+     * See also: vips_embed().
+     */
+    export enum Extend {
+        /**
+         * Extend with black (all 0) pixels
+         */
+        black = 'black',
+        /**
+         * Copy the image edges
+         */
+        copy = 'copy',
+        /**
+         * Repeat the whole image
+         */
+        repeat = 'repeat',
+        /**
+         * Mirror the whole image
+         */
+        mirror = 'mirror',
+        /**
+         * Extend with white (all bits set) pixels
+         */
+        white = 'white',
+        /**
+         * Extend with colour from the @background property
+         */
+        background = 'background'
+    }
+
+    /**
+     * A direction on a compass. Used for vips_gravity(), for example.
+     */
+    export enum CompassDirection {
+        /**
+         * Centre
+         */
+        centre = 'centre',
+        /**
+         * North
+         */
+        north = 'north',
+        /**
+         * East
+         */
+        east = 'east',
+        /**
+         * South
+         */
+        south = 'south',
+        /**
+         * West
+         */
+        west = 'west',
+        /**
+         * North-east
+         */
+        north_east = 'north-east',
+        /**
+         * South-east
+         */
+        south_east = 'south-east',
+        /**
+         * South-west
+         */
+        south_west = 'south-west',
+        /**
+         * North-west
+         */
+        north_west = 'north-west'
+    }
+
+    /**
+     * See vips_flip(), vips_join() and so on.
+     * 
+     * Operations like vips_flip() need to be told whether to flip left-right or
+     * top-bottom.
+     * 
+     * See also: vips_flip(), vips_join().
+     */
+    export enum Direction {
+        /**
+         * Left-right
+         */
+        horizontal = 'horizontal',
+        /**
+         * Top-bottom
+         */
+        vertical = 'vertical'
+    }
+
+    /**
+     * See vips_join() and so on.
+     * 
+     * Operations like vips_join() need to be told whether to align images on the
+     * low or high coordinate edge, or centre.
+     * 
+     * See also: vips_join().
+     */
+    export enum Align {
+        /**
+         * Align low coordinate edge
+         */
+        low = 'low',
+        /**
+         * Align centre
+         */
+        centre = 'centre',
+        /**
+         * Align high coordinate edge
+         */
+        high = 'high'
+    }
+
+    /**
+     * Pick the algorithm vips uses to decide image "interestingness". This is used
+     * by vips_smartcrop(), for example, to decide what parts of the image to
+     * keep.
+     * 
+     * #VIPS_INTERESTING_NONE and #VIPS_INTERESTING_LOW mean the same -- the
+     * crop is positioned at the top or left. #VIPS_INTERESTING_HIGH positions at
+     * the bottom or right.
+     * 
+     * See also: vips_smartcrop().
+     */
+    export enum Interesting {
+        /**
+         * Do nothing
+         */
+        none = 'none',
+        /**
+         * Just take the centre
+         */
+        centre = 'centre',
+        /**
+         * Use an entropy measure
+         */
+        entropy = 'entropy',
+        /**
+         * Look for features likely to draw human attention
+         */
+        attention = 'attention',
+        /**
+         * Position the crop towards the low coordinate
+         */
+        low = 'low',
+        /**
+         * Position the crop towards the high coordinate
+         */
+        high = 'high',
+        /**
+         * Everything is interesting
+         */
+        all = 'all'
+    }
+
+    /**
+     * See vips_rot() and so on.
+     * 
+     * Fixed rotate angles.
+     * 
+     * See also: vips_rot().
+     */
+    export enum Angle {
+        /**
+         * No rotate
+         */
+        d0 = 'd0',
+        /**
+         * 90 degrees clockwise
+         */
+        d90 = 'd90',
+        /**
+         * 180 degree rotate
+         */
+        d180 = 'd180',
+        /**
+         * 90 degrees anti-clockwise
+         */
+        d270 = 'd270'
+    }
+
+    /**
+     * See vips_rot45() and so on.
+     * 
+     * Fixed rotate angles.
+     * 
+     * See also: vips_rot45().
+     */
+    export enum Angle45 {
+        /**
+         * No rotate
+         */
+        d0 = 'd0',
+        /**
+         * 45 degrees clockwise
+         */
+        d45 = 'd45',
+        /**
+         * 90 degrees clockwise
+         */
+        d90 = 'd90',
+        /**
+         * 135 degrees clockwise
+         */
+        d135 = 'd135',
+        /**
+         * 180 degrees
+         */
+        d180 = 'd180',
+        /**
+         * 135 degrees anti-clockwise
+         */
+        d225 = 'd225',
+        /**
+         * 90 degrees anti-clockwise
+         */
+        d270 = 'd270',
+        /**
+         * 45 degrees anti-clockwise
+         */
+        d315 = 'd315'
+    }
+
+    /**
+     * How accurate an operation should be.
+     */
+    export enum Precision {
+        /**
+         * Int everywhere
+         */
+        integer = 'integer',
+        /**
+         * Float everywhere
+         */
+        float = 'float',
+        /**
+         * Approximate integer output
+         */
+        approximate = 'approximate'
+    }
+
+    /**
+     * How sensitive loaders are to errors, from never stop (very insensitive), to
+     * stop on the smallest warning (very sensitive).
+     * 
+     * Each one implies the ones before it, so #VIPS_FAIL_ON_ERROR implies
+     * #VIPS_FAIL_ON_TRUNCATED.
+     */
+    export enum FailOn {
+        /**
+         * Never stop
+         */
+        none = 'none',
+        /**
+         * Stop on image truncated, nothing else
+         */
+        truncated = 'truncated',
+        /**
+         * Stop on serious error or truncation
+         */
+        error = 'error',
+        /**
+         * Stop on anything, even warnings
+         */
+        warning = 'warning'
+    }
+
+    /**
+     * The netpbm file format to save as.
+     * 
+     * #VIPS_FOREIGN_PPM_FORMAT_PBM images are single bit.
+     * 
+     * #VIPS_FOREIGN_PPM_FORMAT_PGM images are 8, 16, or 32-bits, one band.
+     * 
+     * #VIPS_FOREIGN_PPM_FORMAT_PPM images are 8, 16, or 32-bits, three bands.
+     * 
+     * #VIPS_FOREIGN_PPM_FORMAT_PFM images are 32-bit float pixels.
+     */
+    export enum ForeignPpmFormat {
+        /**
+         * Portable bitmap
+         */
+        pbm = 'pbm',
+        /**
+         * Portable greymap
+         */
+        pgm = 'pgm',
+        /**
+         * Portable pixmap
+         */
+        ppm = 'ppm',
+        /**
+         * Portable float map
+         */
+        pfm = 'pfm'
+    }
+
+    /**
+     * Set subsampling mode.
+     */
+    export enum ForeignSubsample {
+        /**
+         * Prevent subsampling when quality >= 90
+         */
+        auto = 'auto',
+        /**
+         * Always perform subsampling
+         */
+        on = 'on',
+        /**
+         * Never perform subsampling
+         */
+        off = 'off'
+    }
+
+    /**
+     * What directory layout and metadata standard to use.
+     */
+    export enum ForeignDzLayout {
+        /**
+         * Use DeepZoom directory layout
+         */
+        dz = 'dz',
+        /**
+         * Use Zoomify directory layout
+         */
+        zoomify = 'zoomify',
+        /**
+         * Use Google maps directory layout
+         */
+        google = 'google',
+        /**
+         * Use IIIF v2 directory layout
+         */
+        iiif = 'iiif',
+        /**
+         * Use IIIF v3 directory layout
+         */
+        iiif3 = 'iiif3'
+    }
+
+    /**
+     * How many pyramid layers to create.
+     */
+    export enum ForeignDzDepth {
+        /**
+         * Create layers down to 1x1 pixel
+         */
+        onepixel = 'onepixel',
+        /**
+         * Create layers down to 1x1 tile
+         */
+        onetile = 'onetile',
+        /**
+         * Only create a single layer
+         */
+        one = 'one'
+    }
+
+    /**
+     * How many pyramid layers to create.
+     */
+    export enum ForeignDzContainer {
+        /**
+         * Write tiles to the filesystem
+         */
+        fs = 'fs',
+        /**
+         * Write tiles to a zip file
+         */
+        zip = 'zip',
+        /**
+         * Write to a szi file
+         */
+        szi = 'szi'
+    }
+
+    /**
+     * How to calculate the output pixels when shrinking a 2x2 region.
+     */
+    export enum RegionShrink {
+        /**
+         * Use the average
+         */
+        mean = 'mean',
+        /**
+         * Use the median
+         */
+        median = 'median',
+        /**
+         * Use the mode
+         */
+        mode = 'mode',
+        /**
+         * Use the maximum
+         */
+        max = 'max',
+        /**
+         * Use the minimum
+         */
+        min = 'min',
+        /**
+         * Use the top-left pixel
+         */
+        nearest = 'nearest'
+    }
+
+    /**
+     * Tune lossy encoder settings for different image types.
+     */
+    export enum ForeignWebpPreset {
+        /**
+         * Default preset
+         */
+        default = 'default',
+        /**
+         * Digital picture, like portrait, inner shot
+         */
+        picture = 'picture',
+        /**
+         * Outdoor photograph, with natural lighting
+         */
+        photo = 'photo',
+        /**
+         * Hand or line drawing, with high-contrast details
+         */
+        drawing = 'drawing',
+        /**
+         * Small-sized colorful images
+         */
+        icon = 'icon',
+        /**
+         * Text-like
+         */
+        text = 'text'
+    }
+
+    /**
+     * The compression types supported by the tiff writer.
+     * 
+     * Use @Q to set the jpeg compression level, default 75.
+     * 
+     * Use @predictor to set the lzw or deflate prediction, default horizontal.
+     * 
+     * Use @lossless to set WEBP lossless compression.
+     * 
+     * Use @level to set webp and zstd compression level.
+     */
+    export enum ForeignTiffCompression {
+        /**
+         * No compression
+         */
+        none = 'none',
+        /**
+         * Jpeg compression
+         */
+        jpeg = 'jpeg',
+        /**
+         * Deflate (zip) compression
+         */
+        deflate = 'deflate',
+        /**
+         * Packbits compression
+         */
+        packbits = 'packbits',
+        /**
+         * Fax4 compression
+         */
+        ccittfax4 = 'ccittfax4',
+        /**
+         * LZW compression
+         */
+        lzw = 'lzw',
+        /**
+         * WEBP compression
+         */
+        webp = 'webp',
+        /**
+         * ZSTD compression
+         */
+        zstd = 'zstd',
+        /**
+         * JP2K compression
+         */
+        jp2k = 'jp2k'
+    }
+
+    /**
+     * The predictor can help deflate and lzw compression. The values are fixed by
+     * the tiff library.
+     */
+    export enum ForeignTiffPredictor {
+        /**
+         * No prediction
+         */
+        none = 'none',
+        /**
+         * Horizontal differencing
+         */
+        horizontal = 'horizontal',
+        /**
+         * Float predictor
+         */
+        float = 'float'
+    }
+
+    /**
+     * Use inches or centimeters as the resolution unit for a tiff file.
+     */
+    export enum ForeignTiffResunit {
+        /**
+         * Use centimeters
+         */
+        cm = 'cm',
+        /**
+         * Use inches
+         */
+        inch = 'inch'
+    }
+
+    /**
+     * The compression format to use inside a HEIF container.
+     * 
+     * This is assumed to use the same numbering as %heif_compression_format.
+     */
+    export enum ForeignHeifCompression {
+        /**
+         * X265
+         */
+        hevc = 'hevc',
+        /**
+         * X264
+         */
+        avc = 'avc',
+        /**
+         * Jpeg
+         */
+        jpeg = 'jpeg',
+        /**
+         * Aom
+         */
+        av1 = 'av1'
+    }
+
+    /**
+     * Controls whether an operation should upsize, downsize, both up and
+     * downsize, or force a size.
+     * 
+     * See also: vips_thumbnail().
+     */
+    export enum Size {
+        /**
+         * Size both up and down
+         */
+        both = 'both',
+        /**
+         * Only upsize
+         */
+        up = 'up',
+        /**
+         * Only downsize
+         */
+        down = 'down',
+        /**
+         * Force size, that is, break aspect ratio
+         */
+        force = 'force'
+    }
+
+    /**
+     * The rendering intent. #VIPS_INTENT_ABSOLUTE is best for
+     * scientific work, #VIPS_INTENT_RELATIVE is usually best for
+     * accurate communication with other imaging libraries.
+     */
+    export enum Intent {
+        /**
+         * Perceptual rendering intent
+         */
+        perceptual = 'perceptual',
+        /**
+         * Relative colorimetric rendering intent
+         */
+        relative = 'relative',
+        /**
+         * Saturation rendering intent
+         */
+        saturation = 'saturation',
+        /**
+         * Absolute colorimetric rendering intent
+         */
+        absolute = 'absolute'
+    }
+
+    /**
+     * The resampling kernels vips supports. See vips_reduce(), for example.
+     */
+    export enum Kernel {
+        /**
+         * The nearest pixel to the point.
+         */
+        nearest = 'nearest',
+        /**
+         * Convolve with a triangle filter.
+         */
+        linear = 'linear',
+        /**
+         * Convolve with a cubic filter.
+         */
+        cubic = 'cubic',
+        /**
+         * Convolve with a Mitchell kernel.
+         */
+        mitchell = 'mitchell',
+        /**
+         * Convolve with a two-lobe Lanczos kernel.
+         */
+        lanczos2 = 'lanczos2',
+        /**
+         * Convolve with a three-lobe Lanczos kernel.
+         */
+        lanczos3 = 'lanczos3'
+    }
+
+    /**
+     * Pick a Profile Connection Space for vips_icc_import() and
+     * vips_icc_export(). LAB is usually best, XYZ can be more convenient in some
+     * cases.
+     */
+    export enum PCS {
+        /**
+         * Use CIELAB D65 as the Profile Connection Space
+         */
+        lab = 'lab',
+        /**
+         * Use XYZ as the Profile Connection Space
+         */
+        xyz = 'xyz'
+    }
+
+    /**
+     * More like hit-miss, really.
+     * 
+     * See also: vips_morph().
+     */
+    export enum OperationMorphology {
+        /**
+         * True if all set
+         */
+        erode = 'erode',
+        /**
+         * True if one set
+         */
+        dilate = 'dilate'
+    }
+
+    /**
+     * See vips_draw_image() and so on.
+     * 
+     * Operations like vips_draw_image() need to be told how to combine images
+     * from two sources.
+     * 
+     * See also: vips_join().
+     */
+    export enum CombineMode {
+        /**
+         * Set pixels to the new value
+         */
+        set = 'set',
+        /**
+         * Add pixels
+         */
+        add = 'add'
+    }
+
+    /**
+     * http://www.w3.org/TR/PNG-Filters.html
+     * The values mirror those of png.h in libpng.
+     */
+    export enum ForeignPngFilter {
+        /**
+         * No filtering
+         */
+        none = 'none',
+        /**
+         * Difference to the left
+         */
+        sub = 'sub',
+        /**
+         * Difference up
+         */
+        up = 'up',
+        /**
+         * Average of left and up
+         */
+        avg = 'avg',
+        /**
+         * Pick best neighbor predictor automatically
+         */
+        paeth = 'paeth',
+        /**
+         * Adaptive
+         */
+        all = 'all'
+    }
+
+    class ImageAutoGen {
+        // THIS IS A GENERATED CLASS. DO NOT EDIT DIRECTLY.
+
+        /**
+         * Load an analyze6 image.
+         * @param filename Filename to load from.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static analyzeload(filename: string, options?: {
+            /**
+             * Force open via memory.
+             */
+            memory?: boolean
+            /**
+             * Required access pattern for this file.
+             */
+            access?: Access | Enum
+            /**
+             * Error level to fail on.
+             */
+            fail_on?: FailOn | Enum
+            /**
+             * Flags for this file (output).
+             */
+            flags?: number | undefined
+        }): Image;
+
+        /**
+         * Join an array of images.
+         * @param _in Array of input images.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static arrayjoin(_in: ArrayImage | ArrayConstant, options?: {
+            /**
+             * Number of images across grid.
+             */
+            across?: number
+            /**
+             * Pixels between images.
+             */
+            shim?: number
+            /**
+             * Colour for new pixels.
+             */
+            background?: ArrayConstant
+            /**
+             * Align on the left, centre or right.
+             */
+            halign?: Align | Enum
+            /**
+             * Align on the top, centre or bottom.
+             */
+            valign?: Align | Enum
+            /**
+             * Horizontal spacing between images.
+             */
+            hspacing?: number
+            /**
+             * Vertical spacing between images.
+             */
+            vspacing?: number
+        }): Image;
+
+        /**
+         * Bandwise join a set of images.
+         * @param _in Array of input images.
+         * @return Output image.
+         */
+        static bandjoin(_in: ArrayImage | ArrayConstant): Image;
+
+        /**
+         * Band-wise rank of a set of images.
+         * @param _in Array of input images.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static bandrank(_in: ArrayImage | ArrayConstant, options?: {
+            /**
+             * Select this band element from sorted list.
+             */
+            index?: number
+        }): Image;
+
+        /**
+         * Make a black image.
+         * @param width Image width in pixels.
+         * @param height Image height in pixels.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static black(width: number, height: number, options?: {
+            /**
+             * Number of bands in image.
+             */
+            bands?: number
+        }): Image;
+
+        /**
+         * Load csv.
+         * @param filename Filename to load from.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static csvload(filename: string, options?: {
+            /**
+             * Skip this many lines at the start of the file.
+             */
+            skip?: number
+            /**
+             * Read this many lines from the file.
+             */
+            lines?: number
+            /**
+             * Set of whitespace characters.
+             */
+            whitespace?: string
+            /**
+             * Set of separator characters.
+             */
+            separator?: string
+            /**
+             * Force open via memory.
+             */
+            memory?: boolean
+            /**
+             * Required access pattern for this file.
+             */
+            access?: Access | Enum
+            /**
+             * Error level to fail on.
+             */
+            fail_on?: FailOn | Enum
+            /**
+             * Flags for this file (output).
+             */
+            flags?: number | undefined
+        }): Image;
+
+        /**
+         * Load csv.
+         * @param source Source to load from.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static csvloadSource(source: Source, options?: {
+            /**
+             * Skip this many lines at the start of the file.
+             */
+            skip?: number
+            /**
+             * Read this many lines from the file.
+             */
+            lines?: number
+            /**
+             * Set of whitespace characters.
+             */
+            whitespace?: string
+            /**
+             * Set of separator characters.
+             */
+            separator?: string
+            /**
+             * Force open via memory.
+             */
+            memory?: boolean
+            /**
+             * Required access pattern for this file.
+             */
+            access?: Access | Enum
+            /**
+             * Error level to fail on.
+             */
+            fail_on?: FailOn | Enum
+            /**
+             * Flags for this file (output).
+             */
+            flags?: number | undefined
+        }): Image;
+
+        /**
+         * Make an image showing the eye's spatial response.
+         * @param width Image width in pixels.
+         * @param height Image height in pixels.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static eye(width: number, height: number, options?: {
+            /**
+             * Output an unsigned char image.
+             */
+            uchar?: boolean
+            /**
+             * Maximum spatial frequency.
+             */
+            factor?: number
+        }): Image;
+
+        /**
+         * Load a fits image.
+         * @param filename Filename to load from.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static fitsload(filename: string, options?: {
+            /**
+             * Force open via memory.
+             */
+            memory?: boolean
+            /**
+             * Required access pattern for this file.
+             */
+            access?: Access | Enum
+            /**
+             * Error level to fail on.
+             */
+            fail_on?: FailOn | Enum
+            /**
+             * Flags for this file (output).
+             */
+            flags?: number | undefined
+        }): Image;
+
+        /**
+         * Load fits from a source.
+         * @param source Source to load from.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static fitsloadSource(source: Source, options?: {
+            /**
+             * Force open via memory.
+             */
+            memory?: boolean
+            /**
+             * Required access pattern for this file.
+             */
+            access?: Access | Enum
+            /**
+             * Error level to fail on.
+             */
+            fail_on?: FailOn | Enum
+            /**
+             * Flags for this file (output).
+             */
+            flags?: number | undefined
+        }): Image;
+
+        /**
+         * Make a fractal surface.
+         * @param width Image width in pixels.
+         * @param height Image height in pixels.
+         * @param fractal_dimension Fractal dimension.
+         * @return Output image.
+         */
+        static fractsurf(width: number, height: number, fractal_dimension: number): Image;
+
+        /**
+         * Make a gaussian image.
+         * @param sigma Sigma of Gaussian.
+         * @param min_ampl Minimum amplitude of Gaussian.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static gaussmat(sigma: number, min_ampl: number, options?: {
+            /**
+             * Generate separable gaussian.
+             */
+            separable?: boolean
+            /**
+             * Generate with this precision.
+             */
+            precision?: Precision | Enum
+        }): Image;
+
+        /**
+         * Make a gaussnoise image.
+         * @param width Image width in pixels.
+         * @param height Image height in pixels.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static gaussnoise(width: number, height: number, options?: {
+            /**
+             * Standard deviation of pixels in generated image.
+             */
+            sigma?: number
+            /**
+             * Mean of pixels in generated image.
+             */
+            mean?: number
+            /**
+             * Random number seed.
+             */
+            seed?: number
+        }): Image;
+
+        /**
+         * Load gif with libnsgif.
+         * @param filename Filename to load from.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static gifload(filename: string, options?: {
+            /**
+             * Load this many pages.
+             */
+            n?: number
+            /**
+             * Load this page from the file.
+             */
+            page?: number
+            /**
+             * Force open via memory.
+             */
+            memory?: boolean
+            /**
+             * Required access pattern for this file.
+             */
+            access?: Access | Enum
+            /**
+             * Error level to fail on.
+             */
+            fail_on?: FailOn | Enum
+            /**
+             * Flags for this file (output).
+             */
+            flags?: number | undefined
+        }): Image;
+
+        /**
+         * Load gif with libnsgif.
+         * @param buffer Buffer to load from.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static gifloadBuffer(buffer: Blob, options?: {
+            /**
+             * Load this many pages.
+             */
+            n?: number
+            /**
+             * Load this page from the file.
+             */
+            page?: number
+            /**
+             * Force open via memory.
+             */
+            memory?: boolean
+            /**
+             * Required access pattern for this file.
+             */
+            access?: Access | Enum
+            /**
+             * Error level to fail on.
+             */
+            fail_on?: FailOn | Enum
+            /**
+             * Flags for this file (output).
+             */
+            flags?: number | undefined
+        }): Image;
+
+        /**
+         * Load gif from source.
+         * @param source Source to load from.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static gifloadSource(source: Source, options?: {
+            /**
+             * Load this many pages.
+             */
+            n?: number
+            /**
+             * Load this page from the file.
+             */
+            page?: number
+            /**
+             * Force open via memory.
+             */
+            memory?: boolean
+            /**
+             * Required access pattern for this file.
+             */
+            access?: Access | Enum
+            /**
+             * Error level to fail on.
+             */
+            fail_on?: FailOn | Enum
+            /**
+             * Flags for this file (output).
+             */
+            flags?: number | undefined
+        }): Image;
+
+        /**
+         * Make a grey ramp image.
+         * @param width Image width in pixels.
+         * @param height Image height in pixels.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static grey(width: number, height: number, options?: {
+            /**
+             * Output an unsigned char image.
+             */
+            uchar?: boolean
+        }): Image;
+
+        /**
+         * Load a heif image.
+         * @param filename Filename to load from.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static heifload(filename: string, options?: {
+            /**
+             * Load this page from the file.
+             */
+            page?: number
+            /**
+             * Load this many pages.
+             */
+            n?: number
+            /**
+             * Fetch thumbnail image.
+             */
+            thumbnail?: boolean
+            /**
+             * Force open via memory.
+             */
+            memory?: boolean
+            /**
+             * Required access pattern for this file.
+             */
+            access?: Access | Enum
+            /**
+             * Error level to fail on.
+             */
+            fail_on?: FailOn | Enum
+            /**
+             * Flags for this file (output).
+             */
+            flags?: number | undefined
+        }): Image;
+
+        /**
+         * Load a heif image.
+         * @param buffer Buffer to load from.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static heifloadBuffer(buffer: Blob, options?: {
+            /**
+             * Load this page from the file.
+             */
+            page?: number
+            /**
+             * Load this many pages.
+             */
+            n?: number
+            /**
+             * Fetch thumbnail image.
+             */
+            thumbnail?: boolean
+            /**
+             * Force open via memory.
+             */
+            memory?: boolean
+            /**
+             * Required access pattern for this file.
+             */
+            access?: Access | Enum
+            /**
+             * Error level to fail on.
+             */
+            fail_on?: FailOn | Enum
+            /**
+             * Flags for this file (output).
+             */
+            flags?: number | undefined
+        }): Image;
+
+        /**
+         * Load a heif image.
+         * @param source Source to load from.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static heifloadSource(source: Source, options?: {
+            /**
+             * Load this page from the file.
+             */
+            page?: number
+            /**
+             * Load this many pages.
+             */
+            n?: number
+            /**
+             * Fetch thumbnail image.
+             */
+            thumbnail?: boolean
+            /**
+             * Force open via memory.
+             */
+            memory?: boolean
+            /**
+             * Required access pattern for this file.
+             */
+            access?: Access | Enum
+            /**
+             * Error level to fail on.
+             */
+            fail_on?: FailOn | Enum
+            /**
+             * Flags for this file (output).
+             */
+            flags?: number | undefined
+        }): Image;
+
+        /**
+         * Make a 1d image where pixel values are indexes.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static identity(options?: {
+            /**
+             * Number of bands in lut.
+             */
+            bands?: number
+            /**
+             * Create a 16-bit lut.
+             */
+            ushort?: boolean
+            /**
+             * Size of 16-bit lut.
+             */
+            size?: number
+        }): Image;
+
+        /**
+         * Load jpeg2000 image.
+         * @param filename Filename to load from.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static jp2kload(filename: string, options?: {
+            /**
+             * Load this page from the image.
+             */
+            page?: number
+            /**
+             * Force open via memory.
+             */
+            memory?: boolean
+            /**
+             * Required access pattern for this file.
+             */
+            access?: Access | Enum
+            /**
+             * Error level to fail on.
+             */
+            fail_on?: FailOn | Enum
+            /**
+             * Flags for this file (output).
+             */
+            flags?: number | undefined
+        }): Image;
+
+        /**
+         * Load jpeg2000 image.
+         * @param buffer Buffer to load from.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static jp2kloadBuffer(buffer: Blob, options?: {
+            /**
+             * Load this page from the image.
+             */
+            page?: number
+            /**
+             * Force open via memory.
+             */
+            memory?: boolean
+            /**
+             * Required access pattern for this file.
+             */
+            access?: Access | Enum
+            /**
+             * Error level to fail on.
+             */
+            fail_on?: FailOn | Enum
+            /**
+             * Flags for this file (output).
+             */
+            flags?: number | undefined
+        }): Image;
+
+        /**
+         * Load jpeg2000 image.
+         * @param source Source to load from.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static jp2kloadSource(source: Source, options?: {
+            /**
+             * Load this page from the image.
+             */
+            page?: number
+            /**
+             * Force open via memory.
+             */
+            memory?: boolean
+            /**
+             * Required access pattern for this file.
+             */
+            access?: Access | Enum
+            /**
+             * Error level to fail on.
+             */
+            fail_on?: FailOn | Enum
+            /**
+             * Flags for this file (output).
+             */
+            flags?: number | undefined
+        }): Image;
+
+        /**
+         * Load jpeg from file.
+         * @param filename Filename to load from.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static jpegload(filename: string, options?: {
+            /**
+             * Shrink factor on load.
+             */
+            shrink?: number
+            /**
+             * Rotate image using exif orientation.
+             */
+            autorotate?: boolean
+            /**
+             * Force open via memory.
+             */
+            memory?: boolean
+            /**
+             * Required access pattern for this file.
+             */
+            access?: Access | Enum
+            /**
+             * Error level to fail on.
+             */
+            fail_on?: FailOn | Enum
+            /**
+             * Flags for this file (output).
+             */
+            flags?: number | undefined
+        }): Image;
+
+        /**
+         * Load jpeg from buffer.
+         * @param buffer Buffer to load from.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static jpegloadBuffer(buffer: Blob, options?: {
+            /**
+             * Shrink factor on load.
+             */
+            shrink?: number
+            /**
+             * Rotate image using exif orientation.
+             */
+            autorotate?: boolean
+            /**
+             * Force open via memory.
+             */
+            memory?: boolean
+            /**
+             * Required access pattern for this file.
+             */
+            access?: Access | Enum
+            /**
+             * Error level to fail on.
+             */
+            fail_on?: FailOn | Enum
+            /**
+             * Flags for this file (output).
+             */
+            flags?: number | undefined
+        }): Image;
+
+        /**
+         * Load image from jpeg source.
+         * @param source Source to load from.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static jpegloadSource(source: Source, options?: {
+            /**
+             * Shrink factor on load.
+             */
+            shrink?: number
+            /**
+             * Rotate image using exif orientation.
+             */
+            autorotate?: boolean
+            /**
+             * Force open via memory.
+             */
+            memory?: boolean
+            /**
+             * Required access pattern for this file.
+             */
+            access?: Access | Enum
+            /**
+             * Error level to fail on.
+             */
+            fail_on?: FailOn | Enum
+            /**
+             * Flags for this file (output).
+             */
+            flags?: number | undefined
+        }): Image;
+
+        /**
+         * Load jpeg-xl image.
+         * @param filename Filename to load from.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static jxlload(filename: string, options?: {
+            /**
+             * Force open via memory.
+             */
+            memory?: boolean
+            /**
+             * Required access pattern for this file.
+             */
+            access?: Access | Enum
+            /**
+             * Error level to fail on.
+             */
+            fail_on?: FailOn | Enum
+            /**
+             * Flags for this file (output).
+             */
+            flags?: number | undefined
+        }): Image;
+
+        /**
+         * Load jpeg-xl image.
+         * @param buffer Buffer to load from.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static jxlloadBuffer(buffer: Blob, options?: {
+            /**
+             * Force open via memory.
+             */
+            memory?: boolean
+            /**
+             * Required access pattern for this file.
+             */
+            access?: Access | Enum
+            /**
+             * Error level to fail on.
+             */
+            fail_on?: FailOn | Enum
+            /**
+             * Flags for this file (output).
+             */
+            flags?: number | undefined
+        }): Image;
+
+        /**
+         * Load jpeg-xl image.
+         * @param source Source to load from.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static jxlloadSource(source: Source, options?: {
+            /**
+             * Force open via memory.
+             */
+            memory?: boolean
+            /**
+             * Required access pattern for this file.
+             */
+            access?: Access | Enum
+            /**
+             * Error level to fail on.
+             */
+            fail_on?: FailOn | Enum
+            /**
+             * Flags for this file (output).
+             */
+            flags?: number | undefined
+        }): Image;
+
+        /**
+         * Make a laplacian of gaussian image.
+         * @param sigma Radius of Gaussian.
+         * @param min_ampl Minimum amplitude of Gaussian.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static logmat(sigma: number, min_ampl: number, options?: {
+            /**
+             * Generate separable gaussian.
+             */
+            separable?: boolean
+            /**
+             * Generate with this precision.
+             */
+            precision?: Precision | Enum
+        }): Image;
+
+        /**
+         * Load file with imagemagick.
+         * @param filename Filename to load from.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static magickload(filename: string, options?: {
+            /**
+             * Canvas resolution for rendering vector formats like svg.
+             */
+            density?: string
+            /**
+             * Load this page from the file.
+             */
+            page?: number
+            /**
+             * Load this many pages.
+             */
+            n?: number
+            /**
+             * Force open via memory.
+             */
+            memory?: boolean
+            /**
+             * Required access pattern for this file.
+             */
+            access?: Access | Enum
+            /**
+             * Error level to fail on.
+             */
+            fail_on?: FailOn | Enum
+            /**
+             * Flags for this file (output).
+             */
+            flags?: number | undefined
+        }): Image;
+
+        /**
+         * Load buffer with imagemagick.
+         * @param buffer Buffer to load from.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static magickloadBuffer(buffer: Blob, options?: {
+            /**
+             * Canvas resolution for rendering vector formats like svg.
+             */
+            density?: string
+            /**
+             * Load this page from the file.
+             */
+            page?: number
+            /**
+             * Load this many pages.
+             */
+            n?: number
+            /**
+             * Force open via memory.
+             */
+            memory?: boolean
+            /**
+             * Required access pattern for this file.
+             */
+            access?: Access | Enum
+            /**
+             * Error level to fail on.
+             */
+            fail_on?: FailOn | Enum
+            /**
+             * Flags for this file (output).
+             */
+            flags?: number | undefined
+        }): Image;
+
+        /**
+         * Make a butterworth filter.
+         * @param width Image width in pixels.
+         * @param height Image height in pixels.
+         * @param order Filter order.
+         * @param frequency_cutoff Frequency cutoff.
+         * @param amplitude_cutoff Amplitude cutoff.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static maskButterworth(width: number, height: number, order: number, frequency_cutoff: number, amplitude_cutoff: number, options?: {
+            /**
+             * Output an unsigned char image.
+             */
+            uchar?: boolean
+            /**
+             * Remove dc component.
+             */
+            nodc?: boolean
+            /**
+             * Invert the sense of the filter.
+             */
+            reject?: boolean
+            /**
+             * Rotate quadrants to optical space.
+             */
+            optical?: boolean
+        }): Image;
+
+        /**
+         * Make a butterworth_band filter.
+         * @param width Image width in pixels.
+         * @param height Image height in pixels.
+         * @param order Filter order.
+         * @param frequency_cutoff_x Frequency cutoff x.
+         * @param frequency_cutoff_y Frequency cutoff y.
+         * @param radius radius of circle.
+         * @param amplitude_cutoff Amplitude cutoff.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static maskButterworthBand(width: number, height: number, order: number, frequency_cutoff_x: number, frequency_cutoff_y: number, radius: number, amplitude_cutoff: number, options?: {
+            /**
+             * Output an unsigned char image.
+             */
+            uchar?: boolean
+            /**
+             * Remove dc component.
+             */
+            nodc?: boolean
+            /**
+             * Invert the sense of the filter.
+             */
+            reject?: boolean
+            /**
+             * Rotate quadrants to optical space.
+             */
+            optical?: boolean
+        }): Image;
+
+        /**
+         * Make a butterworth ring filter.
+         * @param width Image width in pixels.
+         * @param height Image height in pixels.
+         * @param order Filter order.
+         * @param frequency_cutoff Frequency cutoff.
+         * @param amplitude_cutoff Amplitude cutoff.
+         * @param ringwidth Ringwidth.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static maskButterworthRing(width: number, height: number, order: number, frequency_cutoff: number, amplitude_cutoff: number, ringwidth: number, options?: {
+            /**
+             * Output an unsigned char image.
+             */
+            uchar?: boolean
+            /**
+             * Remove dc component.
+             */
+            nodc?: boolean
+            /**
+             * Invert the sense of the filter.
+             */
+            reject?: boolean
+            /**
+             * Rotate quadrants to optical space.
+             */
+            optical?: boolean
+        }): Image;
+
+        /**
+         * Make fractal filter.
+         * @param width Image width in pixels.
+         * @param height Image height in pixels.
+         * @param fractal_dimension Fractal dimension.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static maskFractal(width: number, height: number, fractal_dimension: number, options?: {
+            /**
+             * Output an unsigned char image.
+             */
+            uchar?: boolean
+            /**
+             * Remove dc component.
+             */
+            nodc?: boolean
+            /**
+             * Invert the sense of the filter.
+             */
+            reject?: boolean
+            /**
+             * Rotate quadrants to optical space.
+             */
+            optical?: boolean
+        }): Image;
+
+        /**
+         * Make a gaussian filter.
+         * @param width Image width in pixels.
+         * @param height Image height in pixels.
+         * @param frequency_cutoff Frequency cutoff.
+         * @param amplitude_cutoff Amplitude cutoff.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static maskGaussian(width: number, height: number, frequency_cutoff: number, amplitude_cutoff: number, options?: {
+            /**
+             * Output an unsigned char image.
+             */
+            uchar?: boolean
+            /**
+             * Remove dc component.
+             */
+            nodc?: boolean
+            /**
+             * Invert the sense of the filter.
+             */
+            reject?: boolean
+            /**
+             * Rotate quadrants to optical space.
+             */
+            optical?: boolean
+        }): Image;
+
+        /**
+         * Make a gaussian filter.
+         * @param width Image width in pixels.
+         * @param height Image height in pixels.
+         * @param frequency_cutoff_x Frequency cutoff x.
+         * @param frequency_cutoff_y Frequency cutoff y.
+         * @param radius radius of circle.
+         * @param amplitude_cutoff Amplitude cutoff.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static maskGaussianBand(width: number, height: number, frequency_cutoff_x: number, frequency_cutoff_y: number, radius: number, amplitude_cutoff: number, options?: {
+            /**
+             * Output an unsigned char image.
+             */
+            uchar?: boolean
+            /**
+             * Remove dc component.
+             */
+            nodc?: boolean
+            /**
+             * Invert the sense of the filter.
+             */
+            reject?: boolean
+            /**
+             * Rotate quadrants to optical space.
+             */
+            optical?: boolean
+        }): Image;
+
+        /**
+         * Make a gaussian ring filter.
+         * @param width Image width in pixels.
+         * @param height Image height in pixels.
+         * @param frequency_cutoff Frequency cutoff.
+         * @param amplitude_cutoff Amplitude cutoff.
+         * @param ringwidth Ringwidth.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static maskGaussianRing(width: number, height: number, frequency_cutoff: number, amplitude_cutoff: number, ringwidth: number, options?: {
+            /**
+             * Output an unsigned char image.
+             */
+            uchar?: boolean
+            /**
+             * Remove dc component.
+             */
+            nodc?: boolean
+            /**
+             * Invert the sense of the filter.
+             */
+            reject?: boolean
+            /**
+             * Rotate quadrants to optical space.
+             */
+            optical?: boolean
+        }): Image;
+
+        /**
+         * Make an ideal filter.
+         * @param width Image width in pixels.
+         * @param height Image height in pixels.
+         * @param frequency_cutoff Frequency cutoff.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static maskIdeal(width: number, height: number, frequency_cutoff: number, options?: {
+            /**
+             * Output an unsigned char image.
+             */
+            uchar?: boolean
+            /**
+             * Remove dc component.
+             */
+            nodc?: boolean
+            /**
+             * Invert the sense of the filter.
+             */
+            reject?: boolean
+            /**
+             * Rotate quadrants to optical space.
+             */
+            optical?: boolean
+        }): Image;
+
+        /**
+         * Make an ideal band filter.
+         * @param width Image width in pixels.
+         * @param height Image height in pixels.
+         * @param frequency_cutoff_x Frequency cutoff x.
+         * @param frequency_cutoff_y Frequency cutoff y.
+         * @param radius radius of circle.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static maskIdealBand(width: number, height: number, frequency_cutoff_x: number, frequency_cutoff_y: number, radius: number, options?: {
+            /**
+             * Output an unsigned char image.
+             */
+            uchar?: boolean
+            /**
+             * Remove dc component.
+             */
+            nodc?: boolean
+            /**
+             * Invert the sense of the filter.
+             */
+            reject?: boolean
+            /**
+             * Rotate quadrants to optical space.
+             */
+            optical?: boolean
+        }): Image;
+
+        /**
+         * Make an ideal ring filter.
+         * @param width Image width in pixels.
+         * @param height Image height in pixels.
+         * @param frequency_cutoff Frequency cutoff.
+         * @param ringwidth Ringwidth.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static maskIdealRing(width: number, height: number, frequency_cutoff: number, ringwidth: number, options?: {
+            /**
+             * Output an unsigned char image.
+             */
+            uchar?: boolean
+            /**
+             * Remove dc component.
+             */
+            nodc?: boolean
+            /**
+             * Invert the sense of the filter.
+             */
+            reject?: boolean
+            /**
+             * Rotate quadrants to optical space.
+             */
+            optical?: boolean
+        }): Image;
+
+        /**
+         * Load mat from file.
+         * @param filename Filename to load from.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static matload(filename: string, options?: {
+            /**
+             * Force open via memory.
+             */
+            memory?: boolean
+            /**
+             * Required access pattern for this file.
+             */
+            access?: Access | Enum
+            /**
+             * Error level to fail on.
+             */
+            fail_on?: FailOn | Enum
+            /**
+             * Flags for this file (output).
+             */
+            flags?: number | undefined
+        }): Image;
+
+        /**
+         * Load matrix.
+         * @param filename Filename to load from.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static matrixload(filename: string, options?: {
+            /**
+             * Force open via memory.
+             */
+            memory?: boolean
+            /**
+             * Required access pattern for this file.
+             */
+            access?: Access | Enum
+            /**
+             * Error level to fail on.
+             */
+            fail_on?: FailOn | Enum
+            /**
+             * Flags for this file (output).
+             */
+            flags?: number | undefined
+        }): Image;
+
+        /**
+         * Load matrix.
+         * @param source Source to load from.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static matrixloadSource(source: Source, options?: {
+            /**
+             * Force open via memory.
+             */
+            memory?: boolean
+            /**
+             * Required access pattern for this file.
+             */
+            access?: Access | Enum
+            /**
+             * Error level to fail on.
+             */
+            fail_on?: FailOn | Enum
+            /**
+             * Flags for this file (output).
+             */
+            flags?: number | undefined
+        }): Image;
+
+        /**
+         * Load nifti volume.
+         * @param filename Filename to load from.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static niftiload(filename: string, options?: {
+            /**
+             * Force open via memory.
+             */
+            memory?: boolean
+            /**
+             * Required access pattern for this file.
+             */
+            access?: Access | Enum
+            /**
+             * Error level to fail on.
+             */
+            fail_on?: FailOn | Enum
+            /**
+             * Flags for this file (output).
+             */
+            flags?: number | undefined
+        }): Image;
+
+        /**
+         * Load nifti volumes.
+         * @param source Source to load from.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static niftiloadSource(source: Source, options?: {
+            /**
+             * Force open via memory.
+             */
+            memory?: boolean
+            /**
+             * Required access pattern for this file.
+             */
+            access?: Access | Enum
+            /**
+             * Error level to fail on.
+             */
+            fail_on?: FailOn | Enum
+            /**
+             * Flags for this file (output).
+             */
+            flags?: number | undefined
+        }): Image;
+
+        /**
+         * Load an openexr image.
+         * @param filename Filename to load from.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static openexrload(filename: string, options?: {
+            /**
+             * Force open via memory.
+             */
+            memory?: boolean
+            /**
+             * Required access pattern for this file.
+             */
+            access?: Access | Enum
+            /**
+             * Error level to fail on.
+             */
+            fail_on?: FailOn | Enum
+            /**
+             * Flags for this file (output).
+             */
+            flags?: number | undefined
+        }): Image;
+
+        /**
+         * Load file with openslide.
+         * @param filename Filename to load from.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static openslideload(filename: string, options?: {
+            /**
+             * Attach all associated images.
+             */
+            attach_associated?: boolean
+            /**
+             * Load this level from the file.
+             */
+            level?: number
+            /**
+             * Crop to image bounds.
+             */
+            autocrop?: boolean
+            /**
+             * Load this associated image.
+             */
+            associated?: string
+            /**
+             * Force open via memory.
+             */
+            memory?: boolean
+            /**
+             * Required access pattern for this file.
+             */
+            access?: Access | Enum
+            /**
+             * Error level to fail on.
+             */
+            fail_on?: FailOn | Enum
+            /**
+             * Flags for this file (output).
+             */
+            flags?: number | undefined
+        }): Image;
+
+        /**
+         * Load source with openslide.
+         * @param source Source to load from.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static openslideloadSource(source: Source, options?: {
+            /**
+             * Attach all associated images.
+             */
+            attach_associated?: boolean
+            /**
+             * Load this level from the file.
+             */
+            level?: number
+            /**
+             * Crop to image bounds.
+             */
+            autocrop?: boolean
+            /**
+             * Load this associated image.
+             */
+            associated?: string
+            /**
+             * Force open via memory.
+             */
+            memory?: boolean
+            /**
+             * Required access pattern for this file.
+             */
+            access?: Access | Enum
+            /**
+             * Error level to fail on.
+             */
+            fail_on?: FailOn | Enum
+            /**
+             * Flags for this file (output).
+             */
+            flags?: number | undefined
+        }): Image;
+
+        /**
+         * Load pdf from file.
+         * @param filename Filename to load from.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static pdfload(filename: string, options?: {
+            /**
+             * Load this page from the file.
+             */
+            page?: number
+            /**
+             * Load this many pages.
+             */
+            n?: number
+            /**
+             * Render at this dpi.
+             */
+            dpi?: number
+            /**
+             * Scale output by this factor.
+             */
+            scale?: number
+            /**
+             * Background value.
+             */
+            background?: ArrayConstant
+            /**
+             * Force open via memory.
+             */
+            memory?: boolean
+            /**
+             * Required access pattern for this file.
+             */
+            access?: Access | Enum
+            /**
+             * Error level to fail on.
+             */
+            fail_on?: FailOn | Enum
+            /**
+             * Flags for this file (output).
+             */
+            flags?: number | undefined
+        }): Image;
+
+        /**
+         * Load pdf from buffer.
+         * @param buffer Buffer to load from.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static pdfloadBuffer(buffer: Blob, options?: {
+            /**
+             * Load this page from the file.
+             */
+            page?: number
+            /**
+             * Load this many pages.
+             */
+            n?: number
+            /**
+             * Render at this dpi.
+             */
+            dpi?: number
+            /**
+             * Scale output by this factor.
+             */
+            scale?: number
+            /**
+             * Background value.
+             */
+            background?: ArrayConstant
+            /**
+             * Force open via memory.
+             */
+            memory?: boolean
+            /**
+             * Required access pattern for this file.
+             */
+            access?: Access | Enum
+            /**
+             * Error level to fail on.
+             */
+            fail_on?: FailOn | Enum
+            /**
+             * Flags for this file (output).
+             */
+            flags?: number | undefined
+        }): Image;
+
+        /**
+         * Load pdf from source.
+         * @param source Source to load from.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static pdfloadSource(source: Source, options?: {
+            /**
+             * Load this page from the file.
+             */
+            page?: number
+            /**
+             * Load this many pages.
+             */
+            n?: number
+            /**
+             * Render at this dpi.
+             */
+            dpi?: number
+            /**
+             * Scale output by this factor.
+             */
+            scale?: number
+            /**
+             * Background value.
+             */
+            background?: ArrayConstant
+            /**
+             * Force open via memory.
+             */
+            memory?: boolean
+            /**
+             * Required access pattern for this file.
+             */
+            access?: Access | Enum
+            /**
+             * Error level to fail on.
+             */
+            fail_on?: FailOn | Enum
+            /**
+             * Flags for this file (output).
+             */
+            flags?: number | undefined
+        }): Image;
+
+        /**
+         * Make a perlin noise image.
+         * @param width Image width in pixels.
+         * @param height Image height in pixels.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static perlin(width: number, height: number, options?: {
+            /**
+             * Size of perlin cells.
+             */
+            cell_size?: number
+            /**
+             * Output an unsigned char image.
+             */
+            uchar?: boolean
+            /**
+             * Random number seed.
+             */
+            seed?: number
+        }): Image;
+
+        /**
+         * Load png from file.
+         * @param filename Filename to load from.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static pngload(filename: string, options?: {
+            /**
+             * Remove all denial of service limits.
+             */
+            unlimited?: boolean
+            /**
+             * Force open via memory.
+             */
+            memory?: boolean
+            /**
+             * Required access pattern for this file.
+             */
+            access?: Access | Enum
+            /**
+             * Error level to fail on.
+             */
+            fail_on?: FailOn | Enum
+            /**
+             * Flags for this file (output).
+             */
+            flags?: number | undefined
+        }): Image;
+
+        /**
+         * Load png from buffer.
+         * @param buffer Buffer to load from.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static pngloadBuffer(buffer: Blob, options?: {
+            /**
+             * Remove all denial of service limits.
+             */
+            unlimited?: boolean
+            /**
+             * Force open via memory.
+             */
+            memory?: boolean
+            /**
+             * Required access pattern for this file.
+             */
+            access?: Access | Enum
+            /**
+             * Error level to fail on.
+             */
+            fail_on?: FailOn | Enum
+            /**
+             * Flags for this file (output).
+             */
+            flags?: number | undefined
+        }): Image;
+
+        /**
+         * Load png from source.
+         * @param source Source to load from.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static pngloadSource(source: Source, options?: {
+            /**
+             * Remove all denial of service limits.
+             */
+            unlimited?: boolean
+            /**
+             * Force open via memory.
+             */
+            memory?: boolean
+            /**
+             * Required access pattern for this file.
+             */
+            access?: Access | Enum
+            /**
+             * Error level to fail on.
+             */
+            fail_on?: FailOn | Enum
+            /**
+             * Flags for this file (output).
+             */
+            flags?: number | undefined
+        }): Image;
+
+        /**
+         * Load ppm from file.
+         * @param filename Filename to load from.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static ppmload(filename: string, options?: {
+            /**
+             * Force open via memory.
+             */
+            memory?: boolean
+            /**
+             * Required access pattern for this file.
+             */
+            access?: Access | Enum
+            /**
+             * Error level to fail on.
+             */
+            fail_on?: FailOn | Enum
+            /**
+             * Flags for this file (output).
+             */
+            flags?: number | undefined
+        }): Image;
+
+        /**
+         * Load ppm base class.
+         * @param source Source to load from.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static ppmloadSource(source: Source, options?: {
+            /**
+             * Force open via memory.
+             */
+            memory?: boolean
+            /**
+             * Required access pattern for this file.
+             */
+            access?: Access | Enum
+            /**
+             * Error level to fail on.
+             */
+            fail_on?: FailOn | Enum
+            /**
+             * Flags for this file (output).
+             */
+            flags?: number | undefined
+        }): Image;
+
+        /**
+         * Load named icc profile.
+         * @param name Profile name.
+         * @return Loaded profile.
+         */
+        static profileLoad(name: string): Uint8Array;
+
+        /**
+         * Load a radiance image from a file.
+         * @param filename Filename to load from.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static radload(filename: string, options?: {
+            /**
+             * Force open via memory.
+             */
+            memory?: boolean
+            /**
+             * Required access pattern for this file.
+             */
+            access?: Access | Enum
+            /**
+             * Error level to fail on.
+             */
+            fail_on?: FailOn | Enum
+            /**
+             * Flags for this file (output).
+             */
+            flags?: number | undefined
+        }): Image;
+
+        /**
+         * Load rad from buffer.
+         * @param buffer Buffer to load from.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static radloadBuffer(buffer: Blob, options?: {
+            /**
+             * Force open via memory.
+             */
+            memory?: boolean
+            /**
+             * Required access pattern for this file.
+             */
+            access?: Access | Enum
+            /**
+             * Error level to fail on.
+             */
+            fail_on?: FailOn | Enum
+            /**
+             * Flags for this file (output).
+             */
+            flags?: number | undefined
+        }): Image;
+
+        /**
+         * Load rad from source.
+         * @param source Source to load from.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static radloadSource(source: Source, options?: {
+            /**
+             * Force open via memory.
+             */
+            memory?: boolean
+            /**
+             * Required access pattern for this file.
+             */
+            access?: Access | Enum
+            /**
+             * Error level to fail on.
+             */
+            fail_on?: FailOn | Enum
+            /**
+             * Flags for this file (output).
+             */
+            flags?: number | undefined
+        }): Image;
+
+        /**
+         * Load raw data from a file.
+         * @param filename Filename to load from.
+         * @param width Image width in pixels.
+         * @param height Image height in pixels.
+         * @param bands Number of bands in image.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static rawload(filename: string, width: number, height: number, bands: number, options?: {
+            /**
+             * Offset in bytes from start of file.
+             */
+            offset?: number
+            /**
+             * Pixel format in image.
+             */
+            format?: BandFormat | Enum
+            /**
+             * Pixel interpretation.
+             */
+            interpretation?: Interpretation | Enum
+            /**
+             * Force open via memory.
+             */
+            memory?: boolean
+            /**
+             * Required access pattern for this file.
+             */
+            access?: Access | Enum
+            /**
+             * Error level to fail on.
+             */
+            fail_on?: FailOn | Enum
+            /**
+             * Flags for this file (output).
+             */
+            flags?: number | undefined
+        }): Image;
+
+        /**
+         * Make a 2d sine wave.
+         * @param width Image width in pixels.
+         * @param height Image height in pixels.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static sines(width: number, height: number, options?: {
+            /**
+             * Output an unsigned char image.
+             */
+            uchar?: boolean
+            /**
+             * Horizontal spatial frequency.
+             */
+            hfreq?: number
+            /**
+             * Vertical spatial frequency.
+             */
+            vfreq?: number
+        }): Image;
+
+        /**
+         * Sum an array of images.
+         * @param _in Array of input images.
+         * @return Output image.
+         */
+        static sum(_in: ArrayImage | ArrayConstant): Image;
+
+        /**
+         * Load svg with rsvg.
+         * @param filename Filename to load from.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static svgload(filename: string, options?: {
+            /**
+             * Render at this dpi.
+             */
+            dpi?: number
+            /**
+             * Scale output by this factor.
+             */
+            scale?: number
+            /**
+             * Allow svg of any size.
+             */
+            unlimited?: boolean
+            /**
+             * Force open via memory.
+             */
+            memory?: boolean
+            /**
+             * Required access pattern for this file.
+             */
+            access?: Access | Enum
+            /**
+             * Error level to fail on.
+             */
+            fail_on?: FailOn | Enum
+            /**
+             * Flags for this file (output).
+             */
+            flags?: number | undefined
+        }): Image;
+
+        /**
+         * Load svg with rsvg.
+         * @param buffer Buffer to load from.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static svgloadBuffer(buffer: Blob, options?: {
+            /**
+             * Render at this dpi.
+             */
+            dpi?: number
+            /**
+             * Scale output by this factor.
+             */
+            scale?: number
+            /**
+             * Allow svg of any size.
+             */
+            unlimited?: boolean
+            /**
+             * Force open via memory.
+             */
+            memory?: boolean
+            /**
+             * Required access pattern for this file.
+             */
+            access?: Access | Enum
+            /**
+             * Error level to fail on.
+             */
+            fail_on?: FailOn | Enum
+            /**
+             * Flags for this file (output).
+             */
+            flags?: number | undefined
+        }): Image;
+
+        /**
+         * Load svg from source.
+         * @param source Source to load from.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static svgloadSource(source: Source, options?: {
+            /**
+             * Render at this dpi.
+             */
+            dpi?: number
+            /**
+             * Scale output by this factor.
+             */
+            scale?: number
+            /**
+             * Allow svg of any size.
+             */
+            unlimited?: boolean
+            /**
+             * Force open via memory.
+             */
+            memory?: boolean
+            /**
+             * Required access pattern for this file.
+             */
+            access?: Access | Enum
+            /**
+             * Error level to fail on.
+             */
+            fail_on?: FailOn | Enum
+            /**
+             * Flags for this file (output).
+             */
+            flags?: number | undefined
+        }): Image;
+
+        /**
+         * Find the index of the first non-zero pixel in tests.
+         * @param tests Table of images to test.
+         * @return Output image.
+         */
+        static switch(tests: ArrayImage | ArrayConstant): Image;
+
+        /**
+         * Run an external command.
+         * @param cmd_format Command to run.
+         * @param options Optional options.
+         */
+        static system(cmd_format: string, options?: {
+            /**
+             * Array of input images.
+             */
+            _in?: ArrayImage | ArrayConstant
+            /**
+             * Format for output filename.
+             */
+            out_format?: string
+            /**
+             * Format for input filename.
+             */
+            in_format?: string
+            /**
+             * Output image (output).
+             */
+            out?: Image | undefined
+            /**
+             * Command log (output).
+             */
+            log?: string | undefined
+        }): void;
+
+        /**
+         * Make a text image.
+         * @param text Text to render.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static text(text: string, options?: {
+            /**
+             * Font to render with.
+             */
+            font?: string
+            /**
+             * Maximum image width in pixels.
+             */
+            width?: number
+            /**
+             * Maximum image height in pixels.
+             */
+            height?: number
+            /**
+             * Align on the low, centre or high edge.
+             */
+            align?: Align | Enum
+            /**
+             * Enable rgba output.
+             */
+            rgba?: boolean
+            /**
+             * Dpi to render at.
+             */
+            dpi?: number
+            /**
+             * Justify lines.
+             */
+            justify?: boolean
+            /**
+             * Line spacing.
+             */
+            spacing?: number
+            /**
+             * Load this font file.
+             */
+            fontfile?: string
+            /**
+             * Dpi selected by autofit (output).
+             */
+            autofit_dpi?: number | undefined
+        }): Image;
+
+        /**
+         * Generate thumbnail from file.
+         * @param filename Filename to read from.
+         * @param width Size to this width.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static thumbnail(filename: string, width: number, options?: {
+            /**
+             * Size to this height.
+             */
+            height?: number
+            /**
+             * Only upsize, only downsize, or both.
+             */
+            size?: Size | Enum
+            /**
+             * Don't use orientation tags to rotate image upright.
+             */
+            no_rotate?: boolean
+            /**
+             * Reduce to fill target rectangle, then crop.
+             */
+            crop?: Interesting | Enum
+            /**
+             * Reduce in linear light.
+             */
+            linear?: boolean
+            /**
+             * Fallback import profile.
+             */
+            import_profile?: string
+            /**
+             * Fallback export profile.
+             */
+            export_profile?: string
+            /**
+             * Rendering intent.
+             */
+            intent?: Intent | Enum
+        }): Image;
+
+        /**
+         * Generate thumbnail from buffer.
+         * @param buffer Buffer to load from.
+         * @param width Size to this width.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static thumbnailBuffer(buffer: Blob, width: number, options?: {
+            /**
+             * Options that are passed on to the underlying loader.
+             */
+            option_string?: string
+            /**
+             * Size to this height.
+             */
+            height?: number
+            /**
+             * Only upsize, only downsize, or both.
+             */
+            size?: Size | Enum
+            /**
+             * Don't use orientation tags to rotate image upright.
+             */
+            no_rotate?: boolean
+            /**
+             * Reduce to fill target rectangle, then crop.
+             */
+            crop?: Interesting | Enum
+            /**
+             * Reduce in linear light.
+             */
+            linear?: boolean
+            /**
+             * Fallback import profile.
+             */
+            import_profile?: string
+            /**
+             * Fallback export profile.
+             */
+            export_profile?: string
+            /**
+             * Rendering intent.
+             */
+            intent?: Intent | Enum
+        }): Image;
+
+        /**
+         * Generate thumbnail from source.
+         * @param source Source to load from.
+         * @param width Size to this width.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static thumbnailSource(source: Source, width: number, options?: {
+            /**
+             * Options that are passed on to the underlying loader.
+             */
+            option_string?: string
+            /**
+             * Size to this height.
+             */
+            height?: number
+            /**
+             * Only upsize, only downsize, or both.
+             */
+            size?: Size | Enum
+            /**
+             * Don't use orientation tags to rotate image upright.
+             */
+            no_rotate?: boolean
+            /**
+             * Reduce to fill target rectangle, then crop.
+             */
+            crop?: Interesting | Enum
+            /**
+             * Reduce in linear light.
+             */
+            linear?: boolean
+            /**
+             * Fallback import profile.
+             */
+            import_profile?: string
+            /**
+             * Fallback export profile.
+             */
+            export_profile?: string
+            /**
+             * Rendering intent.
+             */
+            intent?: Intent | Enum
+        }): Image;
+
+        /**
+         * Load tiff from file.
+         * @param filename Filename to load from.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static tiffload(filename: string, options?: {
+            /**
+             * Load this page from the image.
+             */
+            page?: number
+            /**
+             * Select subifd index.
+             */
+            subifd?: number
+            /**
+             * Load this many pages.
+             */
+            n?: number
+            /**
+             * Rotate image using orientation tag.
+             */
+            autorotate?: boolean
+            /**
+             * Force open via memory.
+             */
+            memory?: boolean
+            /**
+             * Required access pattern for this file.
+             */
+            access?: Access | Enum
+            /**
+             * Error level to fail on.
+             */
+            fail_on?: FailOn | Enum
+            /**
+             * Flags for this file (output).
+             */
+            flags?: number | undefined
+        }): Image;
+
+        /**
+         * Load tiff from buffer.
+         * @param buffer Buffer to load from.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static tiffloadBuffer(buffer: Blob, options?: {
+            /**
+             * Load this page from the image.
+             */
+            page?: number
+            /**
+             * Select subifd index.
+             */
+            subifd?: number
+            /**
+             * Load this many pages.
+             */
+            n?: number
+            /**
+             * Rotate image using orientation tag.
+             */
+            autorotate?: boolean
+            /**
+             * Force open via memory.
+             */
+            memory?: boolean
+            /**
+             * Required access pattern for this file.
+             */
+            access?: Access | Enum
+            /**
+             * Error level to fail on.
+             */
+            fail_on?: FailOn | Enum
+            /**
+             * Flags for this file (output).
+             */
+            flags?: number | undefined
+        }): Image;
+
+        /**
+         * Load tiff from source.
+         * @param source Source to load from.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static tiffloadSource(source: Source, options?: {
+            /**
+             * Load this page from the image.
+             */
+            page?: number
+            /**
+             * Select subifd index.
+             */
+            subifd?: number
+            /**
+             * Load this many pages.
+             */
+            n?: number
+            /**
+             * Rotate image using orientation tag.
+             */
+            autorotate?: boolean
+            /**
+             * Force open via memory.
+             */
+            memory?: boolean
+            /**
+             * Required access pattern for this file.
+             */
+            access?: Access | Enum
+            /**
+             * Error level to fail on.
+             */
+            fail_on?: FailOn | Enum
+            /**
+             * Flags for this file (output).
+             */
+            flags?: number | undefined
+        }): Image;
+
+        /**
+         * Build a look-up table.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static tonelut(options?: {
+            /**
+             * Size of lut to build.
+             */
+            in_max?: number
+            /**
+             * Maximum value in output lut.
+             */
+            out_max?: number
+            /**
+             * Lowest value in output.
+             */
+            Lb?: number
+            /**
+             * Highest value in output.
+             */
+            Lw?: number
+            /**
+             * Position of shadow.
+             */
+            Ps?: number
+            /**
+             * Position of mid-tones.
+             */
+            Pm?: number
+            /**
+             * Position of highlights.
+             */
+            Ph?: number
+            /**
+             * Adjust shadows by this much.
+             */
+            S?: number
+            /**
+             * Adjust mid-tones by this much.
+             */
+            M?: number
+            /**
+             * Adjust highlights by this much.
+             */
+            H?: number
+        }): Image;
+
+        /**
+         * Load vips from file.
+         * @param filename Filename to load from.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static vipsload(filename: string, options?: {
+            /**
+             * Force open via memory.
+             */
+            memory?: boolean
+            /**
+             * Required access pattern for this file.
+             */
+            access?: Access | Enum
+            /**
+             * Error level to fail on.
+             */
+            fail_on?: FailOn | Enum
+            /**
+             * Flags for this file (output).
+             */
+            flags?: number | undefined
+        }): Image;
+
+        /**
+         * Load vips from source.
+         * @param source Source to load from.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static vipsloadSource(source: Source, options?: {
+            /**
+             * Force open via memory.
+             */
+            memory?: boolean
+            /**
+             * Required access pattern for this file.
+             */
+            access?: Access | Enum
+            /**
+             * Error level to fail on.
+             */
+            fail_on?: FailOn | Enum
+            /**
+             * Flags for this file (output).
+             */
+            flags?: number | undefined
+        }): Image;
+
+        /**
+         * Load webp from file.
+         * @param filename Filename to load from.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static webpload(filename: string, options?: {
+            /**
+             * Load this page from the file.
+             */
+            page?: number
+            /**
+             * Load this many pages.
+             */
+            n?: number
+            /**
+             * Scale factor on load.
+             */
+            scale?: number
+            /**
+             * Force open via memory.
+             */
+            memory?: boolean
+            /**
+             * Required access pattern for this file.
+             */
+            access?: Access | Enum
+            /**
+             * Error level to fail on.
+             */
+            fail_on?: FailOn | Enum
+            /**
+             * Flags for this file (output).
+             */
+            flags?: number | undefined
+        }): Image;
+
+        /**
+         * Load webp from buffer.
+         * @param buffer Buffer to load from.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static webploadBuffer(buffer: Blob, options?: {
+            /**
+             * Load this page from the file.
+             */
+            page?: number
+            /**
+             * Load this many pages.
+             */
+            n?: number
+            /**
+             * Scale factor on load.
+             */
+            scale?: number
+            /**
+             * Force open via memory.
+             */
+            memory?: boolean
+            /**
+             * Required access pattern for this file.
+             */
+            access?: Access | Enum
+            /**
+             * Error level to fail on.
+             */
+            fail_on?: FailOn | Enum
+            /**
+             * Flags for this file (output).
+             */
+            flags?: number | undefined
+        }): Image;
+
+        /**
+         * Load webp from source.
+         * @param source Source to load from.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static webploadSource(source: Source, options?: {
+            /**
+             * Load this page from the file.
+             */
+            page?: number
+            /**
+             * Load this many pages.
+             */
+            n?: number
+            /**
+             * Scale factor on load.
+             */
+            scale?: number
+            /**
+             * Force open via memory.
+             */
+            memory?: boolean
+            /**
+             * Required access pattern for this file.
+             */
+            access?: Access | Enum
+            /**
+             * Error level to fail on.
+             */
+            fail_on?: FailOn | Enum
+            /**
+             * Flags for this file (output).
+             */
+            flags?: number | undefined
+        }): Image;
+
+        /**
+         * Make a worley noise image.
+         * @param width Image width in pixels.
+         * @param height Image height in pixels.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static worley(width: number, height: number, options?: {
+            /**
+             * Size of worley cells.
+             */
+            cell_size?: number
+            /**
+             * Random number seed.
+             */
+            seed?: number
+        }): Image;
+
+        /**
+         * Make an image where pixel values are coordinates.
+         * @param width Image width in pixels.
+         * @param height Image height in pixels.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static xyz(width: number, height: number, options?: {
+            /**
+             * Size of third dimension.
+             */
+            csize?: number
+            /**
+             * Size of fourth dimension.
+             */
+            dsize?: number
+            /**
+             * Size of fifth dimension.
+             */
+            esize?: number
+        }): Image;
+
+        /**
+         * Make a zone plate.
+         * @param width Image width in pixels.
+         * @param height Image height in pixels.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        static zone(width: number, height: number, options?: {
+            /**
+             * Output an unsigned char image.
+             */
+            uchar?: boolean
+        }): Image;
+
+        /**
+         * Transform lch to cmc.
+         * @return Output image.
+         */
+        CMC2LCh(): Image;
+
+        /**
+         * Transform cmyk to xyz.
+         * @return Output image.
+         */
+        CMYK2XYZ(): Image;
+
+        /**
+         * Transform hsv to srgb.
+         * @return Output image.
+         */
+        HSV2sRGB(): Image;
+
+        /**
+         * Transform lch to cmc.
+         * @return Output image.
+         */
+        LCh2CMC(): Image;
+
+        /**
+         * Transform lch to lab.
+         * @return Output image.
+         */
+        LCh2Lab(): Image;
+
+        /**
+         * Transform lab to lch.
+         * @return Output image.
+         */
+        Lab2LCh(): Image;
+
+        /**
+         * Transform float lab to labq coding.
+         * @return Output image.
+         */
+        Lab2LabQ(): Image;
+
+        /**
+         * Transform float lab to signed short.
+         * @return Output image.
+         */
+        Lab2LabS(): Image;
+
+        /**
+         * Transform cielab to xyz.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        Lab2XYZ(options?: {
+            /**
+             * Color temperature.
+             */
+            temp?: ArrayConstant
+        }): Image;
+
+        /**
+         * Unpack a labq image to float lab.
+         * @return Output image.
+         */
+        LabQ2Lab(): Image;
+
+        /**
+         * Unpack a labq image to short lab.
+         * @return Output image.
+         */
+        LabQ2LabS(): Image;
+
+        /**
+         * Convert a labq image to srgb.
+         * @return Output image.
+         */
+        LabQ2sRGB(): Image;
+
+        /**
+         * Transform signed short lab to float.
+         * @return Output image.
+         */
+        LabS2Lab(): Image;
+
+        /**
+         * Transform short lab to labq coding.
+         * @return Output image.
+         */
+        LabS2LabQ(): Image;
+
+        /**
+         * Transform xyz to cmyk.
+         * @return Output image.
+         */
+        XYZ2CMYK(): Image;
+
+        /**
+         * Transform xyz to lab.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        XYZ2Lab(options?: {
+            /**
+             * Colour temperature.
+             */
+            temp?: ArrayConstant
+        }): Image;
+
+        /**
+         * Transform xyz to yxy.
+         * @return Output image.
+         */
+        XYZ2Yxy(): Image;
+
+        /**
+         * Transform xyz to scrgb.
+         * @return Output image.
+         */
+        XYZ2scRGB(): Image;
+
+        /**
+         * Transform yxy to xyz.
+         * @return Output image.
+         */
+        Yxy2XYZ(): Image;
+
+        /**
+         * Absolute value of an image.
+         * @return Output image.
+         */
+        abs(): Image;
+
+        /**
+         * Add two images.
+         * @param right Right-hand image argument.
+         * @return Output image.
+         */
+        add(right: Image | ArrayConstant): Image;
+
+        /**
+         * Affine transform of an image.
+         * @param matrix Transformation matrix.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        affine(matrix: ArrayConstant, options?: {
+            /**
+             * Interpolate pixels with this.
+             */
+            interpolate?: Interpolate
+            /**
+             * Area of output to generate.
+             */
+            oarea?: ArrayConstant
+            /**
+             * Horizontal output displacement.
+             */
+            odx?: number
+            /**
+             * Vertical output displacement.
+             */
+            ody?: number
+            /**
+             * Horizontal input displacement.
+             */
+            idx?: number
+            /**
+             * Vertical input displacement.
+             */
+            idy?: number
+            /**
+             * Background value.
+             */
+            background?: ArrayConstant
+            /**
+             * Images have premultiplied alpha.
+             */
+            premultiplied?: boolean
+            /**
+             * How to generate the extra pixels.
+             */
+            extend?: Extend | Enum
+        }): Image;
+
+        /**
+         * Autorotate image by exif tag.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        autorot(options?: {
+            /**
+             * Angle image was rotated by (output).
+             */
+            angle?: Angle | undefined
+            /**
+             * Whether the image was flipped or not (output).
+             */
+            flip?: boolean | undefined
+        }): Image;
+
+        /**
+         * Find image average.
+         * @return Output value.
+         */
+        avg(): number;
+
+        /**
+         * Boolean operation across image bands.
+         * @param boolean boolean to perform.
+         * @return Output image.
+         */
+        bandbool(boolean: OperationBoolean | Enum): Image;
+
+        /**
+         * Fold up x axis into bands.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        bandfold(options?: {
+            /**
+             * Fold by this factor.
+             */
+            factor?: number
+        }): Image;
+
+        /**
+         * Band-wise average.
+         * @return Output image.
+         */
+        bandmean(): Image;
+
+        /**
+         * Unfold image bands into x axis.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        bandunfold(options?: {
+            /**
+             * Unfold by this factor.
+             */
+            factor?: number
+        }): Image;
+
+        /**
+         * Boolean operation on two images.
+         * @param right Right-hand image argument.
+         * @param boolean boolean to perform.
+         * @return Output image.
+         */
+        boolean(right: Image | ArrayConstant, boolean: OperationBoolean | Enum): Image;
+
+        /**
+         * Build a look-up table.
+         * @return Output image.
+         */
+        buildlut(): Image;
+
+        /**
+         * Byteswap an image.
+         * @return Output image.
+         */
+        byteswap(): Image;
+
+        /**
+         * Cache an image.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        cache(options?: {
+            /**
+             * Maximum number of tiles to cache.
+             */
+            max_tiles?: number
+            /**
+             * Tile height in pixels.
+             */
+            tile_height?: number
+            /**
+             * Tile width in pixels.
+             */
+            tile_width?: number
+        }): Image;
+
+        /**
+         * Canny edge detector.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        canny(options?: {
+            /**
+             * Sigma of gaussian.
+             */
+            sigma?: number
+            /**
+             * Convolve with this precision.
+             */
+            precision?: Precision | Enum
+        }): Image;
+
+        /**
+         * Use pixel values to pick cases from an array of images.
+         * @param cases Array of case images.
+         * @return Output image.
+         */
+        case(cases: ArrayImage | ArrayConstant): Image;
+
+        /**
+         * Cast an image.
+         * @param format Format to cast to.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        cast(format: BandFormat | Enum, options?: {
+            /**
+             * Shift integer values up and down.
+             */
+            shift?: boolean
+        }): Image;
+
+        /**
+         * Convert to a new colorspace.
+         * @param space Destination color space.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        colourspace(space: Interpretation | Enum, options?: {
+            /**
+             * Source color space.
+             */
+            source_space?: Interpretation | Enum
+        }): Image;
+
+        /**
+         * Convolve with rotating mask.
+         * @param mask Input matrix image.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        compass(mask: Image | ArrayConstant, options?: {
+            /**
+             * Rotate and convolve this many times.
+             */
+            times?: number
+            /**
+             * Rotate mask by this much between convolutions.
+             */
+            angle?: Angle45 | Enum
+            /**
+             * Combine convolution results like this.
+             */
+            combine?: Combine | Enum
+            /**
+             * Convolve with this precision.
+             */
+            precision?: Precision | Enum
+            /**
+             * Use this many layers in approximation.
+             */
+            layers?: number
+            /**
+             * Cluster lines closer than this in approximation.
+             */
+            cluster?: number
+        }): Image;
+
+        /**
+         * Perform a complex operation on an image.
+         * @param cmplx complex to perform.
+         * @return Output image.
+         */
+        complex(cmplx: OperationComplex | Enum): Image;
+
+        /**
+         * Complex binary operations on two images.
+         * @param right Right-hand image argument.
+         * @param cmplx binary complex operation to perform.
+         * @return Output image.
+         */
+        complex2(right: Image | ArrayConstant, cmplx: OperationComplex2 | Enum): Image;
+
+        /**
+         * Form a complex image from two real images.
+         * @param right Right-hand image argument.
+         * @return Output image.
+         */
+        complexform(right: Image | ArrayConstant): Image;
+
+        /**
+         * Get a component from a complex image.
+         * @param get complex to perform.
+         * @return Output image.
+         */
+        complexget(get: OperationComplexget | Enum): Image;
+
+        /**
+         * Blend a pair of images with a blend mode.
+         * @param overlay Overlay image.
+         * @param mode VipsBlendMode to join with.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        composite2(overlay: Image | ArrayConstant, mode: BlendMode | Enum, options?: {
+            /**
+             * X position of overlay.
+             */
+            x?: number
+            /**
+             * Y position of overlay.
+             */
+            y?: number
+            /**
+             * Composite images in this colour space.
+             */
+            compositing_space?: Interpretation | Enum
+            /**
+             * Images have premultiplied alpha.
+             */
+            premultiplied?: boolean
+        }): Image;
+
+        /**
+         * Convolution operation.
+         * @param mask Input matrix image.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        conv(mask: Image | ArrayConstant, options?: {
+            /**
+             * Convolve with this precision.
+             */
+            precision?: Precision | Enum
+            /**
+             * Use this many layers in approximation.
+             */
+            layers?: number
+            /**
+             * Cluster lines closer than this in approximation.
+             */
+            cluster?: number
+        }): Image;
+
+        /**
+         * Approximate integer convolution.
+         * @param mask Input matrix image.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        conva(mask: Image | ArrayConstant, options?: {
+            /**
+             * Use this many layers in approximation.
+             */
+            layers?: number
+            /**
+             * Cluster lines closer than this in approximation.
+             */
+            cluster?: number
+        }): Image;
+
+        /**
+         * Approximate separable integer convolution.
+         * @param mask Input matrix image.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        convasep(mask: Image | ArrayConstant, options?: {
+            /**
+             * Use this many layers in approximation.
+             */
+            layers?: number
+        }): Image;
+
+        /**
+         * Float convolution operation.
+         * @param mask Input matrix image.
+         * @return Output image.
+         */
+        convf(mask: Image | ArrayConstant): Image;
+
+        /**
+         * Int convolution operation.
+         * @param mask Input matrix image.
+         * @return Output image.
+         */
+        convi(mask: Image | ArrayConstant): Image;
+
+        /**
+         * Seperable convolution operation.
+         * @param mask Input matrix image.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        convsep(mask: Image | ArrayConstant, options?: {
+            /**
+             * Convolve with this precision.
+             */
+            precision?: Precision | Enum
+            /**
+             * Use this many layers in approximation.
+             */
+            layers?: number
+            /**
+             * Cluster lines closer than this in approximation.
+             */
+            cluster?: number
+        }): Image;
+
+        /**
+         * Copy an image.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        copy(options?: {
+            /**
+             * Image width in pixels.
+             */
+            width?: number
+            /**
+             * Image height in pixels.
+             */
+            height?: number
+            /**
+             * Number of bands in image.
+             */
+            bands?: number
+            /**
+             * Pixel format in image.
+             */
+            format?: BandFormat | Enum
+            /**
+             * Pixel coding.
+             */
+            coding?: Coding | Enum
+            /**
+             * Pixel interpretation.
+             */
+            interpretation?: Interpretation | Enum
+            /**
+             * Horizontal resolution in pixels/mm.
+             */
+            xres?: number
+            /**
+             * Vertical resolution in pixels/mm.
+             */
+            yres?: number
+            /**
+             * Horizontal offset of origin.
+             */
+            xoffset?: number
+            /**
+             * Vertical offset of origin.
+             */
+            yoffset?: number
+        }): Image;
+
+        /**
+         * Count lines in an image.
+         * @param direction Countlines left-right or up-down.
+         * @return Number of lines.
+         */
+        countlines(direction: Direction | Enum): number;
+
+        /**
+         * Extract an area from an image.
+         * @param left Left edge of extract area.
+         * @param top Top edge of extract area.
+         * @param width Width of extract area.
+         * @param height Height of extract area.
+         * @return Output image.
+         */
+        crop(left: number, top: number, width: number, height: number): Image;
+
+        /**
+         * Save image to csv.
+         * @param filename Filename to save to.
+         * @param options Optional options.
+         */
+        csvsave(filename: string, options?: {
+            /**
+             * Separator characters.
+             */
+            separator?: string
+            /**
+             * Strip all metadata from image.
+             */
+            strip?: boolean
+            /**
+             * Background value.
+             */
+            background?: ArrayConstant
+            /**
+             * Set page height for multipage save.
+             */
+            page_height?: number
+        }): void;
+
+        /**
+         * Save image to csv.
+         * @param target Target to save to.
+         * @param options Optional options.
+         */
+        csvsaveTarget(target: Target, options?: {
+            /**
+             * Separator characters.
+             */
+            separator?: string
+            /**
+             * Strip all metadata from image.
+             */
+            strip?: boolean
+            /**
+             * Background value.
+             */
+            background?: ArrayConstant
+            /**
+             * Set page height for multipage save.
+             */
+            page_height?: number
+        }): void;
+
+        /**
+         * Calculate de00.
+         * @param right Right-hand input image.
+         * @return Output image.
+         */
+        dE00(right: Image | ArrayConstant): Image;
+
+        /**
+         * Calculate de76.
+         * @param right Right-hand input image.
+         * @return Output image.
+         */
+        dE76(right: Image | ArrayConstant): Image;
+
+        /**
+         * Calculate decmc.
+         * @param right Right-hand input image.
+         * @return Output image.
+         */
+        dECMC(right: Image | ArrayConstant): Image;
+
+        /**
+         * Find image standard deviation.
+         * @return Output value.
+         */
+        deviate(): number;
+
+        /**
+         * Divide two images.
+         * @param right Right-hand image argument.
+         * @return Output image.
+         */
+        divide(right: Image | ArrayConstant): Image;
+
+        /**
+         * Draw a circle on an image.
+         * @param ink Color for pixels.
+         * @param cx Centre of draw_circle.
+         * @param cy Centre of draw_circle.
+         * @param radius Radius in pixels.
+         * @param options Optional options.
+         */
+        drawCircle(ink: ArrayConstant, cx: number, cy: number, radius: number, options?: {
+            /**
+             * Draw a solid object.
+             */
+            fill?: boolean
+        }): void;
+
+        /**
+         * Flood-fill an area.
+         * @param ink Color for pixels.
+         * @param x DrawFlood start point.
+         * @param y DrawFlood start point.
+         * @param options Optional options.
+         */
+        drawFlood(ink: ArrayConstant, x: number, y: number, options?: {
+            /**
+             * Test pixels in this image.
+             */
+            test?: Image | ArrayConstant
+            /**
+             * Drawflood while equal to edge.
+             */
+            equal?: boolean
+            /**
+             * Left edge of modified area (output).
+             */
+            left?: number | undefined
+            /**
+             * Top edge of modified area (output).
+             */
+            top?: number | undefined
+            /**
+             * Width of modified area (output).
+             */
+            width?: number | undefined
+            /**
+             * Height of modified area (output).
+             */
+            height?: number | undefined
+        }): void;
+
+        /**
+         * Paint an image into another image.
+         * @param sub Sub-image to insert into main image.
+         * @param x Draw image here.
+         * @param y Draw image here.
+         * @param options Optional options.
+         */
+        drawImage(sub: Image | ArrayConstant, x: number, y: number, options?: {
+            /**
+             * Combining mode.
+             */
+            mode?: CombineMode | Enum
+        }): void;
+
+        /**
+         * Draw a line on an image.
+         * @param ink Color for pixels.
+         * @param x1 Start of draw_line.
+         * @param y1 Start of draw_line.
+         * @param x2 End of draw_line.
+         * @param y2 End of draw_line.
+         */
+        drawLine(ink: ArrayConstant, x1: number, y1: number, x2: number, y2: number): void;
+
+        /**
+         * Draw a mask on an image.
+         * @param ink Color for pixels.
+         * @param mask Mask of pixels to draw.
+         * @param x Draw mask here.
+         * @param y Draw mask here.
+         */
+        drawMask(ink: ArrayConstant, mask: Image | ArrayConstant, x: number, y: number): void;
+
+        /**
+         * Paint a rectangle on an image.
+         * @param ink Color for pixels.
+         * @param left Rect to fill.
+         * @param top Rect to fill.
+         * @param width Rect to fill.
+         * @param height Rect to fill.
+         * @param options Optional options.
+         */
+        drawRect(ink: ArrayConstant, left: number, top: number, width: number, height: number, options?: {
+            /**
+             * Draw a solid object.
+             */
+            fill?: boolean
+        }): void;
+
+        /**
+         * Blur a rectangle on an image.
+         * @param left Rect to fill.
+         * @param top Rect to fill.
+         * @param width Rect to fill.
+         * @param height Rect to fill.
+         */
+        drawSmudge(left: number, top: number, width: number, height: number): void;
+
+        /**
+         * Save image to deepzoom file.
+         * @param filename Filename to save to.
+         * @param options Optional options.
+         */
+        dzsave(filename: string, options?: {
+            /**
+             * Base name to save to.
+             */
+            basename?: string
+            /**
+             * Directory layout.
+             */
+            layout?: ForeignDzLayout | Enum
+            /**
+             * Filename suffix for tiles.
+             */
+            suffix?: string
+            /**
+             * Tile overlap in pixels.
+             */
+            overlap?: number
+            /**
+             * Tile size in pixels.
+             */
+            tile_size?: number
+            /**
+             * Center image in tile.
+             */
+            centre?: boolean
+            /**
+             * Pyramid depth.
+             */
+            depth?: ForeignDzDepth | Enum
+            /**
+             * Rotate image during save.
+             */
+            angle?: Angle | Enum
+            /**
+             * Pyramid container type.
+             */
+            container?: ForeignDzContainer | Enum
+            /**
+             * Write a properties file to the output directory.
+             */
+            properties?: boolean
+            /**
+             * Zip deflate compression level.
+             */
+            compression?: number
+            /**
+             * Method to shrink regions.
+             */
+            region_shrink?: RegionShrink | Enum
+            /**
+             * Skip tiles which are nearly equal to the background.
+             */
+            skip_blanks?: number
+            /**
+             * Don't strip tile metadata.
+             */
+            no_strip?: boolean
+            /**
+             * Resource id.
+             */
+            id?: string
+            /**
+             * Strip all metadata from image.
+             */
+            strip?: boolean
+            /**
+             * Background value.
+             */
+            background?: ArrayConstant
+            /**
+             * Set page height for multipage save.
+             */
+            page_height?: number
+        }): void;
+
+        /**
+         * Save image to dz buffer.
+         * @param options Optional options.
+         * @return Buffer to save to.
+         */
+        dzsaveBuffer(options?: {
+            /**
+             * Base name to save to.
+             */
+            basename?: string
+            /**
+             * Directory layout.
+             */
+            layout?: ForeignDzLayout | Enum
+            /**
+             * Filename suffix for tiles.
+             */
+            suffix?: string
+            /**
+             * Tile overlap in pixels.
+             */
+            overlap?: number
+            /**
+             * Tile size in pixels.
+             */
+            tile_size?: number
+            /**
+             * Center image in tile.
+             */
+            centre?: boolean
+            /**
+             * Pyramid depth.
+             */
+            depth?: ForeignDzDepth | Enum
+            /**
+             * Rotate image during save.
+             */
+            angle?: Angle | Enum
+            /**
+             * Pyramid container type.
+             */
+            container?: ForeignDzContainer | Enum
+            /**
+             * Write a properties file to the output directory.
+             */
+            properties?: boolean
+            /**
+             * Zip deflate compression level.
+             */
+            compression?: number
+            /**
+             * Method to shrink regions.
+             */
+            region_shrink?: RegionShrink | Enum
+            /**
+             * Skip tiles which are nearly equal to the background.
+             */
+            skip_blanks?: number
+            /**
+             * Don't strip tile metadata.
+             */
+            no_strip?: boolean
+            /**
+             * Resource id.
+             */
+            id?: string
+            /**
+             * Strip all metadata from image.
+             */
+            strip?: boolean
+            /**
+             * Background value.
+             */
+            background?: ArrayConstant
+            /**
+             * Set page height for multipage save.
+             */
+            page_height?: number
+        }): Uint8Array;
+
+        /**
+         * Embed an image in a larger image.
+         * @param x Left edge of input in output.
+         * @param y Top edge of input in output.
+         * @param width Image width in pixels.
+         * @param height Image height in pixels.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        embed(x: number, y: number, width: number, height: number, options?: {
+            /**
+             * How to generate the extra pixels.
+             */
+            extend?: Extend | Enum
+            /**
+             * Color for background pixels.
+             */
+            background?: ArrayConstant
+        }): Image;
+
+        /**
+         * Extract an area from an image.
+         * @param left Left edge of extract area.
+         * @param top Top edge of extract area.
+         * @param width Width of extract area.
+         * @param height Height of extract area.
+         * @return Output image.
+         */
+        extractArea(left: number, top: number, width: number, height: number): Image;
+
+        /**
+         * Extract band from an image.
+         * @param band Band to extract.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        extractBand(band: number, options?: {
+            /**
+             * Number of bands to extract.
+             */
+            n?: number
+        }): Image;
+
+        /**
+         * False-color an image.
+         * @return Output image.
+         */
+        falsecolour(): Image;
+
+        /**
+         * Fast correlation.
+         * @param ref Input reference image.
+         * @return Output image.
+         */
+        fastcor(ref: Image | ArrayConstant): Image;
+
+        /**
+         * Fill image zeros with nearest non-zero pixel.
+         * @param options Optional options.
+         * @return Value of nearest non-zero pixel.
+         */
+        fillNearest(options?: {
+            /**
+             * Distance to nearest non-zero pixel (output).
+             */
+            distance?: Image | undefined
+        }): Image;
+
+        /**
+         * Save image to fits file.
+         * @param filename Filename to save to.
+         * @param options Optional options.
+         */
+        fitssave(filename: string, options?: {
+            /**
+             * Strip all metadata from image.
+             */
+            strip?: boolean
+            /**
+             * Background value.
+             */
+            background?: ArrayConstant
+            /**
+             * Set page height for multipage save.
+             */
+            page_height?: number
+        }): void;
+
+        /**
+         * Flatten alpha out of an image.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        flatten(options?: {
+            /**
+             * Background value.
+             */
+            background?: ArrayConstant
+            /**
+             * Maximum value of alpha channel.
+             */
+            max_alpha?: number
+        }): Image;
+
+        /**
+         * Flip an image.
+         * @param direction Direction to flip image.
+         * @return Output image.
+         */
+        flip(direction: Direction | Enum): Image;
+
+        /**
+         * Transform float rgb to radiance coding.
+         * @return Output image.
+         */
+        float2rad(): Image;
+
+        /**
+         * Frequency-domain filtering.
+         * @param mask Input mask image.
+         * @return Output image.
+         */
+        freqmult(mask: Image | ArrayConstant): Image;
+
+        /**
+         * Forward fft.
+         * @return Output image.
+         */
+        fwfft(): Image;
+
+        /**
+         * Gamma an image.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        gamma(options?: {
+            /**
+             * Gamma factor.
+             */
+            exponent?: number
+        }): Image;
+
+        /**
+         * Gaussian blur.
+         * @param sigma Sigma of Gaussian.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        gaussblur(sigma: number, options?: {
+            /**
+             * Minimum amplitude of gaussian.
+             */
+            min_ampl?: number
+            /**
+             * Convolve with this precision.
+             */
+            precision?: Precision | Enum
+        }): Image;
+
+        /**
+         * Read a point from an image.
+         * @param x Point to read.
+         * @param y Point to read.
+         * @return Array of output values.
+         */
+        getpoint(x: number, y: number): number[];
+
+        /**
+         * Save as gif.
+         * @param filename Filename to save to.
+         * @param options Optional options.
+         */
+        gifsave(filename: string, options?: {
+            /**
+             * Amount of dithering.
+             */
+            dither?: number
+            /**
+             * Quantisation effort.
+             */
+            effort?: number
+            /**
+             * Number of bits per pixel.
+             */
+            bitdepth?: number
+            /**
+             * Strip all metadata from image.
+             */
+            strip?: boolean
+            /**
+             * Background value.
+             */
+            background?: ArrayConstant
+            /**
+             * Set page height for multipage save.
+             */
+            page_height?: number
+        }): void;
+
+        /**
+         * Save as gif.
+         * @param options Optional options.
+         * @return Buffer to save to.
+         */
+        gifsaveBuffer(options?: {
+            /**
+             * Amount of dithering.
+             */
+            dither?: number
+            /**
+             * Quantisation effort.
+             */
+            effort?: number
+            /**
+             * Number of bits per pixel.
+             */
+            bitdepth?: number
+            /**
+             * Strip all metadata from image.
+             */
+            strip?: boolean
+            /**
+             * Background value.
+             */
+            background?: ArrayConstant
+            /**
+             * Set page height for multipage save.
+             */
+            page_height?: number
+        }): Uint8Array;
+
+        /**
+         * Save as gif.
+         * @param target Target to save to.
+         * @param options Optional options.
+         */
+        gifsaveTarget(target: Target, options?: {
+            /**
+             * Amount of dithering.
+             */
+            dither?: number
+            /**
+             * Quantisation effort.
+             */
+            effort?: number
+            /**
+             * Number of bits per pixel.
+             */
+            bitdepth?: number
+            /**
+             * Strip all metadata from image.
+             */
+            strip?: boolean
+            /**
+             * Background value.
+             */
+            background?: ArrayConstant
+            /**
+             * Set page height for multipage save.
+             */
+            page_height?: number
+        }): void;
+
+        /**
+         * Global balance an image mosaic.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        globalbalance(options?: {
+            /**
+             * Image gamma.
+             */
+            gamma?: number
+            /**
+             * Integer output.
+             */
+            int_output?: boolean
+        }): Image;
+
+        /**
+         * Place an image within a larger image with a certain gravity.
+         * @param direction direction to place image within width/height.
+         * @param width Image width in pixels.
+         * @param height Image height in pixels.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        gravity(direction: CompassDirection | Enum, width: number, height: number, options?: {
+            /**
+             * How to generate the extra pixels.
+             */
+            extend?: Extend | Enum
+            /**
+             * Color for background pixels.
+             */
+            background?: ArrayConstant
+        }): Image;
+
+        /**
+         * Grid an image.
+         * @param tile_height chop into tiles this high.
+         * @param across number of tiles across.
+         * @param down number of tiles down.
+         * @return Output image.
+         */
+        grid(tile_height: number, across: number, down: number): Image;
+
+        /**
+         * Save image in heif format.
+         * @param filename Filename to save to.
+         * @param options Optional options.
+         */
+        heifsave(filename: string, options?: {
+            /**
+             * Q factor.
+             */
+            Q?: number
+            /**
+             * Enable lossless compression.
+             */
+            lossless?: boolean
+            /**
+             * Compression format.
+             */
+            compression?: ForeignHeifCompression | Enum
+            /**
+             * Cpu effort.
+             */
+            effort?: number
+            /**
+             * Select chroma subsample operation mode.
+             */
+            subsample_mode?: ForeignSubsample | Enum
+            /**
+             * Strip all metadata from image.
+             */
+            strip?: boolean
+            /**
+             * Background value.
+             */
+            background?: ArrayConstant
+            /**
+             * Set page height for multipage save.
+             */
+            page_height?: number
+        }): void;
+
+        /**
+         * Save image in heif format.
+         * @param options Optional options.
+         * @return Buffer to save to.
+         */
+        heifsaveBuffer(options?: {
+            /**
+             * Q factor.
+             */
+            Q?: number
+            /**
+             * Enable lossless compression.
+             */
+            lossless?: boolean
+            /**
+             * Compression format.
+             */
+            compression?: ForeignHeifCompression | Enum
+            /**
+             * Cpu effort.
+             */
+            effort?: number
+            /**
+             * Select chroma subsample operation mode.
+             */
+            subsample_mode?: ForeignSubsample | Enum
+            /**
+             * Strip all metadata from image.
+             */
+            strip?: boolean
+            /**
+             * Background value.
+             */
+            background?: ArrayConstant
+            /**
+             * Set page height for multipage save.
+             */
+            page_height?: number
+        }): Uint8Array;
+
+        /**
+         * Save image in heif format.
+         * @param target Target to save to.
+         * @param options Optional options.
+         */
+        heifsaveTarget(target: Target, options?: {
+            /**
+             * Q factor.
+             */
+            Q?: number
+            /**
+             * Enable lossless compression.
+             */
+            lossless?: boolean
+            /**
+             * Compression format.
+             */
+            compression?: ForeignHeifCompression | Enum
+            /**
+             * Cpu effort.
+             */
+            effort?: number
+            /**
+             * Select chroma subsample operation mode.
+             */
+            subsample_mode?: ForeignSubsample | Enum
+            /**
+             * Strip all metadata from image.
+             */
+            strip?: boolean
+            /**
+             * Background value.
+             */
+            background?: ArrayConstant
+            /**
+             * Set page height for multipage save.
+             */
+            page_height?: number
+        }): void;
+
+        /**
+         * Form cumulative histogram.
+         * @return Output image.
+         */
+        histCum(): Image;
+
+        /**
+         * Estimate image entropy.
+         * @return Output value.
+         */
+        histEntropy(): number;
+
+        /**
+         * Histogram equalisation.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        histEqual(options?: {
+            /**
+             * Equalise with this band.
+             */
+            band?: number
+        }): Image;
+
+        /**
+         * Find image histogram.
+         * @param options Optional options.
+         * @return Output histogram.
+         */
+        histFind(options?: {
+            /**
+             * Find histogram of band.
+             */
+            band?: number
+        }): Image;
+
+        /**
+         * Find indexed image histogram.
+         * @param index Index image.
+         * @param options Optional options.
+         * @return Output histogram.
+         */
+        histFindIndexed(index: Image | ArrayConstant, options?: {
+            /**
+             * Combine bins like this.
+             */
+            combine?: Combine | Enum
+        }): Image;
+
+        /**
+         * Find n-dimensional image histogram.
+         * @param options Optional options.
+         * @return Output histogram.
+         */
+        histFindNdim(options?: {
+            /**
+             * Number of bins in each dimension.
+             */
+            bins?: number
+        }): Image;
+
+        /**
+         * Test for monotonicity.
+         * @return true if in is monotonic.
+         */
+        histIsmonotonic(): boolean;
+
+        /**
+         * Local histogram equalisation.
+         * @param width Window width in pixels.
+         * @param height Window height in pixels.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        histLocal(width: number, height: number, options?: {
+            /**
+             * Maximum slope (clahe).
+             */
+            max_slope?: number
+        }): Image;
+
+        /**
+         * Match two histograms.
+         * @param ref Reference histogram.
+         * @return Output image.
+         */
+        histMatch(ref: Image | ArrayConstant): Image;
+
+        /**
+         * Normalise histogram.
+         * @return Output image.
+         */
+        histNorm(): Image;
+
+        /**
+         * Plot histogram.
+         * @return Output image.
+         */
+        histPlot(): Image;
+
+        /**
+         * Find hough circle transform.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        houghCircle(options?: {
+            /**
+             * Scale down dimensions by this factor.
+             */
+            scale?: number
+            /**
+             * Smallest radius to search for.
+             */
+            min_radius?: number
+            /**
+             * Largest radius to search for.
+             */
+            max_radius?: number
+        }): Image;
+
+        /**
+         * Find hough line transform.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        houghLine(options?: {
+            /**
+             * Horizontal size of parameter space.
+             */
+            width?: number
+            /**
+             * Vertical size of parameter space.
+             */
+            height?: number
+        }): Image;
+
+        /**
+         * Output to device with icc profile.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        iccExport(options?: {
+            /**
+             * Set profile connection space.
+             */
+            pcs?: PCS | Enum
+            /**
+             * Rendering intent.
+             */
+            intent?: Intent | Enum
+            /**
+             * Enable black point compensation.
+             */
+            black_point_compensation?: boolean
+            /**
+             * Filename to load output profile from.
+             */
+            output_profile?: string
+            /**
+             * Output device space depth in bits.
+             */
+            depth?: number
+        }): Image;
+
+        /**
+         * Import from device with icc profile.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        iccImport(options?: {
+            /**
+             * Set profile connection space.
+             */
+            pcs?: PCS | Enum
+            /**
+             * Rendering intent.
+             */
+            intent?: Intent | Enum
+            /**
+             * Enable black point compensation.
+             */
+            black_point_compensation?: boolean
+            /**
+             * Use embedded input profile, if available.
+             */
+            embedded?: boolean
+            /**
+             * Filename to load input profile from.
+             */
+            input_profile?: string
+        }): Image;
+
+        /**
+         * Transform between devices with icc profiles.
+         * @param output_profile Filename to load output profile from.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        iccTransform(output_profile: string, options?: {
+            /**
+             * Set profile connection space.
+             */
+            pcs?: PCS | Enum
+            /**
+             * Rendering intent.
+             */
+            intent?: Intent | Enum
+            /**
+             * Enable black point compensation.
+             */
+            black_point_compensation?: boolean
+            /**
+             * Use embedded input profile, if available.
+             */
+            embedded?: boolean
+            /**
+             * Filename to load input profile from.
+             */
+            input_profile?: string
+            /**
+             * Output device space depth in bits.
+             */
+            depth?: number
+        }): Image;
+
+        /**
+         * Ifthenelse an image.
+         * @param in1 Source for TRUE pixels.
+         * @param in2 Source for FALSE pixels.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        ifthenelse(in1: Image | ArrayConstant, in2: Image | ArrayConstant, options?: {
+            /**
+             * Blend smoothly between then and else parts.
+             */
+            blend?: boolean
+        }): Image;
+
+        /**
+         * Insert image @sub into @main at @x, @y.
+         * @param sub Sub-image to insert into main image.
+         * @param x Left edge of sub in main.
+         * @param y Top edge of sub in main.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        insert(sub: Image | ArrayConstant, x: number, y: number, options?: {
+            /**
+             * Expand output to hold all of both inputs.
+             */
+            expand?: boolean
+            /**
+             * Color for new pixels.
+             */
+            background?: ArrayConstant
+        }): Image;
+
+        /**
+         * Invert an image.
+         * @return Output image.
+         */
+        invert(): Image;
+
+        /**
+         * Build an inverted look-up table.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        invertlut(options?: {
+            /**
+             * Lut size to generate.
+             */
+            size?: number
+        }): Image;
+
+        /**
+         * Inverse fft.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        invfft(options?: {
+            /**
+             * Output only the real part of the transform.
+             */
+            real?: boolean
+        }): Image;
+
+        /**
+         * Join a pair of images.
+         * @param in2 Second input image.
+         * @param direction Join left-right or up-down.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        join(in2: Image | ArrayConstant, direction: Direction | Enum, options?: {
+            /**
+             * Expand output to hold all of both inputs.
+             */
+            expand?: boolean
+            /**
+             * Pixels between images.
+             */
+            shim?: number
+            /**
+             * Colour for new pixels.
+             */
+            background?: ArrayConstant
+            /**
+             * Align on the low, centre or high coordinate edge.
+             */
+            align?: Align | Enum
+        }): Image;
+
+        /**
+         * Save image in jpeg2000 format.
+         * @param filename Filename to load from.
+         * @param options Optional options.
+         */
+        jp2ksave(filename: string, options?: {
+            /**
+             * Tile width in pixels.
+             */
+            tile_width?: number
+            /**
+             * Tile height in pixels.
+             */
+            tile_height?: number
+            /**
+             * Enable lossless compression.
+             */
+            lossless?: boolean
+            /**
+             * Q factor.
+             */
+            Q?: number
+            /**
+             * Select chroma subsample operation mode.
+             */
+            subsample_mode?: ForeignSubsample | Enum
+            /**
+             * Strip all metadata from image.
+             */
+            strip?: boolean
+            /**
+             * Background value.
+             */
+            background?: ArrayConstant
+            /**
+             * Set page height for multipage save.
+             */
+            page_height?: number
+        }): void;
+
+        /**
+         * Save image in jpeg2000 format.
+         * @param options Optional options.
+         * @return Buffer to save to.
+         */
+        jp2ksaveBuffer(options?: {
+            /**
+             * Tile width in pixels.
+             */
+            tile_width?: number
+            /**
+             * Tile height in pixels.
+             */
+            tile_height?: number
+            /**
+             * Enable lossless compression.
+             */
+            lossless?: boolean
+            /**
+             * Q factor.
+             */
+            Q?: number
+            /**
+             * Select chroma subsample operation mode.
+             */
+            subsample_mode?: ForeignSubsample | Enum
+            /**
+             * Strip all metadata from image.
+             */
+            strip?: boolean
+            /**
+             * Background value.
+             */
+            background?: ArrayConstant
+            /**
+             * Set page height for multipage save.
+             */
+            page_height?: number
+        }): Uint8Array;
+
+        /**
+         * Save image in jpeg2000 format.
+         * @param target Target to save to.
+         * @param options Optional options.
+         */
+        jp2ksaveTarget(target: Target, options?: {
+            /**
+             * Tile width in pixels.
+             */
+            tile_width?: number
+            /**
+             * Tile height in pixels.
+             */
+            tile_height?: number
+            /**
+             * Enable lossless compression.
+             */
+            lossless?: boolean
+            /**
+             * Q factor.
+             */
+            Q?: number
+            /**
+             * Select chroma subsample operation mode.
+             */
+            subsample_mode?: ForeignSubsample | Enum
+            /**
+             * Strip all metadata from image.
+             */
+            strip?: boolean
+            /**
+             * Background value.
+             */
+            background?: ArrayConstant
+            /**
+             * Set page height for multipage save.
+             */
+            page_height?: number
+        }): void;
+
+        /**
+         * Save image to jpeg file.
+         * @param filename Filename to save to.
+         * @param options Optional options.
+         */
+        jpegsave(filename: string, options?: {
+            /**
+             * Q factor.
+             */
+            Q?: number
+            /**
+             * Icc profile to embed.
+             */
+            profile?: string
+            /**
+             * Compute optimal huffman coding tables.
+             */
+            optimize_coding?: boolean
+            /**
+             * Generate an interlaced (progressive) jpeg.
+             */
+            interlace?: boolean
+            /**
+             * Apply trellis quantisation to each 8x8 block.
+             */
+            trellis_quant?: boolean
+            /**
+             * Apply overshooting to samples with extreme values.
+             */
+            overshoot_deringing?: boolean
+            /**
+             * Split spectrum of dct coefficients into separate scans.
+             */
+            optimize_scans?: boolean
+            /**
+             * Use predefined quantization table with given index.
+             */
+            quant_table?: number
+            /**
+             * Select chroma subsample operation mode.
+             */
+            subsample_mode?: ForeignSubsample | Enum
+            /**
+             * Add restart markers every specified number of mcu.
+             */
+            restart_interval?: number
+            /**
+             * Strip all metadata from image.
+             */
+            strip?: boolean
+            /**
+             * Background value.
+             */
+            background?: ArrayConstant
+            /**
+             * Set page height for multipage save.
+             */
+            page_height?: number
+        }): void;
+
+        /**
+         * Save image to jpeg buffer.
+         * @param options Optional options.
+         * @return Buffer to save to.
+         */
+        jpegsaveBuffer(options?: {
+            /**
+             * Q factor.
+             */
+            Q?: number
+            /**
+             * Icc profile to embed.
+             */
+            profile?: string
+            /**
+             * Compute optimal huffman coding tables.
+             */
+            optimize_coding?: boolean
+            /**
+             * Generate an interlaced (progressive) jpeg.
+             */
+            interlace?: boolean
+            /**
+             * Apply trellis quantisation to each 8x8 block.
+             */
+            trellis_quant?: boolean
+            /**
+             * Apply overshooting to samples with extreme values.
+             */
+            overshoot_deringing?: boolean
+            /**
+             * Split spectrum of dct coefficients into separate scans.
+             */
+            optimize_scans?: boolean
+            /**
+             * Use predefined quantization table with given index.
+             */
+            quant_table?: number
+            /**
+             * Select chroma subsample operation mode.
+             */
+            subsample_mode?: ForeignSubsample | Enum
+            /**
+             * Add restart markers every specified number of mcu.
+             */
+            restart_interval?: number
+            /**
+             * Strip all metadata from image.
+             */
+            strip?: boolean
+            /**
+             * Background value.
+             */
+            background?: ArrayConstant
+            /**
+             * Set page height for multipage save.
+             */
+            page_height?: number
+        }): Uint8Array;
+
+        /**
+         * Save image to jpeg mime.
+         * @param options Optional options.
+         */
+        jpegsaveMime(options?: {
+            /**
+             * Q factor.
+             */
+            Q?: number
+            /**
+             * Icc profile to embed.
+             */
+            profile?: string
+            /**
+             * Compute optimal huffman coding tables.
+             */
+            optimize_coding?: boolean
+            /**
+             * Generate an interlaced (progressive) jpeg.
+             */
+            interlace?: boolean
+            /**
+             * Apply trellis quantisation to each 8x8 block.
+             */
+            trellis_quant?: boolean
+            /**
+             * Apply overshooting to samples with extreme values.
+             */
+            overshoot_deringing?: boolean
+            /**
+             * Split spectrum of dct coefficients into separate scans.
+             */
+            optimize_scans?: boolean
+            /**
+             * Use predefined quantization table with given index.
+             */
+            quant_table?: number
+            /**
+             * Select chroma subsample operation mode.
+             */
+            subsample_mode?: ForeignSubsample | Enum
+            /**
+             * Add restart markers every specified number of mcu.
+             */
+            restart_interval?: number
+            /**
+             * Strip all metadata from image.
+             */
+            strip?: boolean
+            /**
+             * Background value.
+             */
+            background?: ArrayConstant
+            /**
+             * Set page height for multipage save.
+             */
+            page_height?: number
+        }): void;
+
+        /**
+         * Save image to jpeg target.
+         * @param target Target to save to.
+         * @param options Optional options.
+         */
+        jpegsaveTarget(target: Target, options?: {
+            /**
+             * Q factor.
+             */
+            Q?: number
+            /**
+             * Icc profile to embed.
+             */
+            profile?: string
+            /**
+             * Compute optimal huffman coding tables.
+             */
+            optimize_coding?: boolean
+            /**
+             * Generate an interlaced (progressive) jpeg.
+             */
+            interlace?: boolean
+            /**
+             * Apply trellis quantisation to each 8x8 block.
+             */
+            trellis_quant?: boolean
+            /**
+             * Apply overshooting to samples with extreme values.
+             */
+            overshoot_deringing?: boolean
+            /**
+             * Split spectrum of dct coefficients into separate scans.
+             */
+            optimize_scans?: boolean
+            /**
+             * Use predefined quantization table with given index.
+             */
+            quant_table?: number
+            /**
+             * Select chroma subsample operation mode.
+             */
+            subsample_mode?: ForeignSubsample | Enum
+            /**
+             * Add restart markers every specified number of mcu.
+             */
+            restart_interval?: number
+            /**
+             * Strip all metadata from image.
+             */
+            strip?: boolean
+            /**
+             * Background value.
+             */
+            background?: ArrayConstant
+            /**
+             * Set page height for multipage save.
+             */
+            page_height?: number
+        }): void;
+
+        /**
+         * Save image in jpeg-xl format.
+         * @param filename Filename to load from.
+         * @param options Optional options.
+         */
+        jxlsave(filename: string, options?: {
+            /**
+             * Decode speed tier.
+             */
+            tier?: number
+            /**
+             * Target butteraugli distance.
+             */
+            distance?: number
+            /**
+             * Encoding effort.
+             */
+            effort?: number
+            /**
+             * Enable lossless compression.
+             */
+            lossless?: boolean
+            /**
+             * Quality factor.
+             */
+            Q?: number
+            /**
+             * Strip all metadata from image.
+             */
+            strip?: boolean
+            /**
+             * Background value.
+             */
+            background?: ArrayConstant
+            /**
+             * Set page height for multipage save.
+             */
+            page_height?: number
+        }): void;
+
+        /**
+         * Save image in jpeg-xl format.
+         * @param options Optional options.
+         * @return Buffer to save to.
+         */
+        jxlsaveBuffer(options?: {
+            /**
+             * Decode speed tier.
+             */
+            tier?: number
+            /**
+             * Target butteraugli distance.
+             */
+            distance?: number
+            /**
+             * Encoding effort.
+             */
+            effort?: number
+            /**
+             * Enable lossless compression.
+             */
+            lossless?: boolean
+            /**
+             * Quality factor.
+             */
+            Q?: number
+            /**
+             * Strip all metadata from image.
+             */
+            strip?: boolean
+            /**
+             * Background value.
+             */
+            background?: ArrayConstant
+            /**
+             * Set page height for multipage save.
+             */
+            page_height?: number
+        }): Uint8Array;
+
+        /**
+         * Save image in jpeg-xl format.
+         * @param target Target to save to.
+         * @param options Optional options.
+         */
+        jxlsaveTarget(target: Target, options?: {
+            /**
+             * Decode speed tier.
+             */
+            tier?: number
+            /**
+             * Target butteraugli distance.
+             */
+            distance?: number
+            /**
+             * Encoding effort.
+             */
+            effort?: number
+            /**
+             * Enable lossless compression.
+             */
+            lossless?: boolean
+            /**
+             * Quality factor.
+             */
+            Q?: number
+            /**
+             * Strip all metadata from image.
+             */
+            strip?: boolean
+            /**
+             * Background value.
+             */
+            background?: ArrayConstant
+            /**
+             * Set page height for multipage save.
+             */
+            page_height?: number
+        }): void;
+
+        /**
+         * Label regions in an image.
+         * @param options Optional options.
+         * @return Mask of region labels.
+         */
+        labelregions(options?: {
+            /**
+             * Number of discrete contigious regions (output).
+             */
+            segments?: number | undefined
+        }): Image;
+
+        /**
+         * Calculate (a * in + b).
+         * @param a Multiply by this.
+         * @param b Add this.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        linear(a: ArrayConstant, b: ArrayConstant, options?: {
+            /**
+             * Output should be uchar.
+             */
+            uchar?: boolean
+        }): Image;
+
+        /**
+         * Cache an image as a set of lines.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        linecache(options?: {
+            /**
+             * Tile height in pixels.
+             */
+            tile_height?: number
+            /**
+             * Expected access pattern.
+             */
+            access?: Access | Enum
+            /**
+             * Allow threaded access.
+             */
+            threaded?: boolean
+            /**
+             * Keep cache between evaluations.
+             */
+            persistent?: boolean
+        }): Image;
+
+        /**
+         * Save file with imagemagick.
+         * @param filename Filename to save to.
+         * @param options Optional options.
+         */
+        magicksave(filename: string, options?: {
+            /**
+             * Format to save in.
+             */
+            format?: string
+            /**
+             * Quality to use.
+             */
+            quality?: number
+            /**
+             * Apply gif frames optimization.
+             */
+            optimize_gif_frames?: boolean
+            /**
+             * Apply gif transparency optimization.
+             */
+            optimize_gif_transparency?: boolean
+            /**
+             * Strip all metadata from image.
+             */
+            strip?: boolean
+            /**
+             * Background value.
+             */
+            background?: ArrayConstant
+            /**
+             * Set page height for multipage save.
+             */
+            page_height?: number
+        }): void;
+
+        /**
+         * Save image to magick buffer.
+         * @param options Optional options.
+         * @return Buffer to save to.
+         */
+        magicksaveBuffer(options?: {
+            /**
+             * Format to save in.
+             */
+            format?: string
+            /**
+             * Quality to use.
+             */
+            quality?: number
+            /**
+             * Apply gif frames optimization.
+             */
+            optimize_gif_frames?: boolean
+            /**
+             * Apply gif transparency optimization.
+             */
+            optimize_gif_transparency?: boolean
+            /**
+             * Strip all metadata from image.
+             */
+            strip?: boolean
+            /**
+             * Background value.
+             */
+            background?: ArrayConstant
+            /**
+             * Set page height for multipage save.
+             */
+            page_height?: number
+        }): Uint8Array;
+
+        /**
+         * Resample with a map image.
+         * @param index Index pixels with this.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        mapim(index: Image | ArrayConstant, options?: {
+            /**
+             * Interpolate pixels with this.
+             */
+            interpolate?: Interpolate
+        }): Image;
+
+        /**
+         * Map an image though a lut.
+         * @param lut Look-up table image.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        maplut(lut: Image | ArrayConstant, options?: {
+            /**
+             * Apply one-band lut to this band of in.
+             */
+            band?: number
+        }): Image;
+
+        /**
+         * First-order match of two images.
+         * @param sec Secondary image.
+         * @param xr1 Position of first reference tie-point.
+         * @param yr1 Position of first reference tie-point.
+         * @param xs1 Position of first secondary tie-point.
+         * @param ys1 Position of first secondary tie-point.
+         * @param xr2 Position of second reference tie-point.
+         * @param yr2 Position of second reference tie-point.
+         * @param xs2 Position of second secondary tie-point.
+         * @param ys2 Position of second secondary tie-point.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        match(sec: Image | ArrayConstant, xr1: number, yr1: number, xs1: number, ys1: number, xr2: number, yr2: number, xs2: number, ys2: number, options?: {
+            /**
+             * Half window size.
+             */
+            hwindow?: number
+            /**
+             * Half area size.
+             */
+            harea?: number
+            /**
+             * Search to improve tie-points.
+             */
+            search?: boolean
+            /**
+             * Interpolate pixels with this.
+             */
+            interpolate?: Interpolate
+        }): Image;
+
+        /**
+         * Apply a math operation to an image.
+         * @param math math to perform.
+         * @return Output image.
+         */
+        math(math: OperationMath | Enum): Image;
+
+        /**
+         * Binary math operations.
+         * @param right Right-hand image argument.
+         * @param math2 math to perform.
+         * @return Output image.
+         */
+        math2(right: Image | ArrayConstant, math2: OperationMath2 | Enum): Image;
+
+        /**
+         * Invert an matrix.
+         * @return Output matrix.
+         */
+        matrixinvert(): Image;
+
+        /**
+         * Print matrix.
+         * @param options Optional options.
+         */
+        matrixprint(options?: {
+            /**
+             * Strip all metadata from image.
+             */
+            strip?: boolean
+            /**
+             * Background value.
+             */
+            background?: ArrayConstant
+            /**
+             * Set page height for multipage save.
+             */
+            page_height?: number
+        }): void;
+
+        /**
+         * Save image to matrix.
+         * @param filename Filename to save to.
+         * @param options Optional options.
+         */
+        matrixsave(filename: string, options?: {
+            /**
+             * Strip all metadata from image.
+             */
+            strip?: boolean
+            /**
+             * Background value.
+             */
+            background?: ArrayConstant
+            /**
+             * Set page height for multipage save.
+             */
+            page_height?: number
+        }): void;
+
+        /**
+         * Save image to matrix.
+         * @param target Target to save to.
+         * @param options Optional options.
+         */
+        matrixsaveTarget(target: Target, options?: {
+            /**
+             * Strip all metadata from image.
+             */
+            strip?: boolean
+            /**
+             * Background value.
+             */
+            background?: ArrayConstant
+            /**
+             * Set page height for multipage save.
+             */
+            page_height?: number
+        }): void;
+
+        /**
+         * Find image maximum.
+         * @param options Optional options.
+         * @return Output value.
+         */
+        max(options?: {
+            /**
+             * Number of maximum values to find.
+             */
+            size?: number
+            /**
+             * Horizontal position of maximum (output).
+             */
+            x?: number | undefined
+            /**
+             * Vertical position of maximum (output).
+             */
+            y?: number | undefined
+            /**
+             * Array of output values (output).
+             */
+            out_array?: number[] | undefined
+            /**
+             * Array of horizontal positions (output).
+             */
+            x_array?: number[] | undefined
+            /**
+             * Array of vertical positions (output).
+             */
+            y_array?: number[] | undefined
+        }): number;
+
+        /**
+         * Measure a set of patches on a color chart.
+         * @param h Number of patches across chart.
+         * @param v Number of patches down chart.
+         * @param options Optional options.
+         * @return Output array of statistics.
+         */
+        measure(h: number, v: number, options?: {
+            /**
+             * Left edge of extract area.
+             */
+            left?: number
+            /**
+             * Top edge of extract area.
+             */
+            top?: number
+            /**
+             * Width of extract area.
+             */
+            width?: number
+            /**
+             * Height of extract area.
+             */
+            height?: number
+        }): Image;
+
+        /**
+         * Merge two images.
+         * @param sec Secondary image.
+         * @param direction Horizontal or vertical merge.
+         * @param dx Horizontal displacement from sec to ref.
+         * @param dy Vertical displacement from sec to ref.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        merge(sec: Image | ArrayConstant, direction: Direction | Enum, dx: number, dy: number, options?: {
+            /**
+             * Maximum blend size.
+             */
+            mblend?: number
+        }): Image;
+
+        /**
+         * Find image minimum.
+         * @param options Optional options.
+         * @return Output value.
+         */
+        min(options?: {
+            /**
+             * Number of minimum values to find.
+             */
+            size?: number
+            /**
+             * Horizontal position of minimum (output).
+             */
+            x?: number | undefined
+            /**
+             * Vertical position of minimum (output).
+             */
+            y?: number | undefined
+            /**
+             * Array of output values (output).
+             */
+            out_array?: number[] | undefined
+            /**
+             * Array of horizontal positions (output).
+             */
+            x_array?: number[] | undefined
+            /**
+             * Array of vertical positions (output).
+             */
+            y_array?: number[] | undefined
+        }): number;
+
+        /**
+         * Morphology operation.
+         * @param mask Input matrix image.
+         * @param morph Morphological operation to perform.
+         * @return Output image.
+         */
+        morph(mask: Image | ArrayConstant, morph: OperationMorphology | Enum): Image;
+
+        /**
+         * Mosaic two images.
+         * @param sec Secondary image.
+         * @param direction Horizontal or vertical mosaic.
+         * @param xref Position of reference tie-point.
+         * @param yref Position of reference tie-point.
+         * @param xsec Position of secondary tie-point.
+         * @param ysec Position of secondary tie-point.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        mosaic(sec: Image | ArrayConstant, direction: Direction | Enum, xref: number, yref: number, xsec: number, ysec: number, options?: {
+            /**
+             * Half window size.
+             */
+            hwindow?: number
+            /**
+             * Half area size.
+             */
+            harea?: number
+            /**
+             * Maximum blend size.
+             */
+            mblend?: number
+            /**
+             * Band to search for features on.
+             */
+            bandno?: number
+            /**
+             * Detected integer offset (output).
+             */
+            dx0?: number | undefined
+            /**
+             * Detected integer offset (output).
+             */
+            dy0?: number | undefined
+            /**
+             * Detected scale (output).
+             */
+            scale1?: number | undefined
+            /**
+             * Detected rotation (output).
+             */
+            angle1?: number | undefined
+            /**
+             * Detected first-order displacement (output).
+             */
+            dy1?: number | undefined
+            /**
+             * Detected first-order displacement (output).
+             */
+            dx1?: number | undefined
+        }): Image;
+
+        /**
+         * First-order mosaic of two images.
+         * @param sec Secondary image.
+         * @param direction Horizontal or vertical mosaic.
+         * @param xr1 Position of first reference tie-point.
+         * @param yr1 Position of first reference tie-point.
+         * @param xs1 Position of first secondary tie-point.
+         * @param ys1 Position of first secondary tie-point.
+         * @param xr2 Position of second reference tie-point.
+         * @param yr2 Position of second reference tie-point.
+         * @param xs2 Position of second secondary tie-point.
+         * @param ys2 Position of second secondary tie-point.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        mosaic1(sec: Image | ArrayConstant, direction: Direction | Enum, xr1: number, yr1: number, xs1: number, ys1: number, xr2: number, yr2: number, xs2: number, ys2: number, options?: {
+            /**
+             * Half window size.
+             */
+            hwindow?: number
+            /**
+             * Half area size.
+             */
+            harea?: number
+            /**
+             * Search to improve tie-points.
+             */
+            search?: boolean
+            /**
+             * Interpolate pixels with this.
+             */
+            interpolate?: Interpolate
+            /**
+             * Maximum blend size.
+             */
+            mblend?: number
+            /**
+             * Band to search for features on.
+             */
+            bandno?: number
+        }): Image;
+
+        /**
+         * Pick most-significant byte from an image.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        msb(options?: {
+            /**
+             * Band to msb.
+             */
+            band?: number
+        }): Image;
+
+        /**
+         * Multiply two images.
+         * @param right Right-hand image argument.
+         * @return Output image.
+         */
+        multiply(right: Image | ArrayConstant): Image;
+
+        /**
+         * Save image to nifti file.
+         * @param filename Filename to save to.
+         * @param options Optional options.
+         */
+        niftisave(filename: string, options?: {
+            /**
+             * Strip all metadata from image.
+             */
+            strip?: boolean
+            /**
+             * Background value.
+             */
+            background?: ArrayConstant
+            /**
+             * Set page height for multipage save.
+             */
+            page_height?: number
+        }): void;
+
+        /**
+         * Find threshold for percent of pixels.
+         * @param percent Percent of pixels.
+         * @return Threshold above which lie percent of pixels.
+         */
+        percent(percent: number): number;
+
+        /**
+         * Calculate phase correlation.
+         * @param in2 Second input image.
+         * @return Output image.
+         */
+        phasecor(in2: Image | ArrayConstant): Image;
+
+        /**
+         * Save image to png file.
+         * @param filename Filename to save to.
+         * @param options Optional options.
+         */
+        pngsave(filename: string, options?: {
+            /**
+             * Compression factor.
+             */
+            compression?: number
+            /**
+             * Interlace image.
+             */
+            interlace?: boolean
+            /**
+             * Icc profile to embed.
+             */
+            profile?: string
+            /**
+             * Libpng row filter flag(s).
+             */
+            filter?: ForeignPngFilter | Flag
+            /**
+             * Quantise to 8bpp palette.
+             */
+            palette?: boolean
+            /**
+             * Quantisation quality.
+             */
+            Q?: number
+            /**
+             * Amount of dithering.
+             */
+            dither?: number
+            /**
+             * Write as a 1, 2, 4, 8 or 16 bit image.
+             */
+            bitdepth?: number
+            /**
+             * Quantisation cpu effort.
+             */
+            effort?: number
+            /**
+             * Strip all metadata from image.
+             */
+            strip?: boolean
+            /**
+             * Background value.
+             */
+            background?: ArrayConstant
+            /**
+             * Set page height for multipage save.
+             */
+            page_height?: number
+        }): void;
+
+        /**
+         * Save image to png buffer.
+         * @param options Optional options.
+         * @return Buffer to save to.
+         */
+        pngsaveBuffer(options?: {
+            /**
+             * Compression factor.
+             */
+            compression?: number
+            /**
+             * Interlace image.
+             */
+            interlace?: boolean
+            /**
+             * Icc profile to embed.
+             */
+            profile?: string
+            /**
+             * Libpng row filter flag(s).
+             */
+            filter?: ForeignPngFilter | Flag
+            /**
+             * Quantise to 8bpp palette.
+             */
+            palette?: boolean
+            /**
+             * Quantisation quality.
+             */
+            Q?: number
+            /**
+             * Amount of dithering.
+             */
+            dither?: number
+            /**
+             * Write as a 1, 2, 4, 8 or 16 bit image.
+             */
+            bitdepth?: number
+            /**
+             * Quantisation cpu effort.
+             */
+            effort?: number
+            /**
+             * Strip all metadata from image.
+             */
+            strip?: boolean
+            /**
+             * Background value.
+             */
+            background?: ArrayConstant
+            /**
+             * Set page height for multipage save.
+             */
+            page_height?: number
+        }): Uint8Array;
+
+        /**
+         * Save image to target as png.
+         * @param target Target to save to.
+         * @param options Optional options.
+         */
+        pngsaveTarget(target: Target, options?: {
+            /**
+             * Compression factor.
+             */
+            compression?: number
+            /**
+             * Interlace image.
+             */
+            interlace?: boolean
+            /**
+             * Icc profile to embed.
+             */
+            profile?: string
+            /**
+             * Libpng row filter flag(s).
+             */
+            filter?: ForeignPngFilter | Flag
+            /**
+             * Quantise to 8bpp palette.
+             */
+            palette?: boolean
+            /**
+             * Quantisation quality.
+             */
+            Q?: number
+            /**
+             * Amount of dithering.
+             */
+            dither?: number
+            /**
+             * Write as a 1, 2, 4, 8 or 16 bit image.
+             */
+            bitdepth?: number
+            /**
+             * Quantisation cpu effort.
+             */
+            effort?: number
+            /**
+             * Strip all metadata from image.
+             */
+            strip?: boolean
+            /**
+             * Background value.
+             */
+            background?: ArrayConstant
+            /**
+             * Set page height for multipage save.
+             */
+            page_height?: number
+        }): void;
+
+        /**
+         * Save image to ppm file.
+         * @param filename Filename to save to.
+         * @param options Optional options.
+         */
+        ppmsave(filename: string, options?: {
+            /**
+             * Format to save in.
+             */
+            format?: ForeignPpmFormat | Enum
+            /**
+             * Save as ascii.
+             */
+            ascii?: boolean
+            /**
+             * Set to 1 to write as a 1 bit image.
+             */
+            bitdepth?: number
+            /**
+             * Strip all metadata from image.
+             */
+            strip?: boolean
+            /**
+             * Background value.
+             */
+            background?: ArrayConstant
+            /**
+             * Set page height for multipage save.
+             */
+            page_height?: number
+        }): void;
+
+        /**
+         * Save to ppm.
+         * @param target Target to save to.
+         * @param options Optional options.
+         */
+        ppmsaveTarget(target: Target, options?: {
+            /**
+             * Format to save in.
+             */
+            format?: ForeignPpmFormat | Enum
+            /**
+             * Save as ascii.
+             */
+            ascii?: boolean
+            /**
+             * Set to 1 to write as a 1 bit image.
+             */
+            bitdepth?: number
+            /**
+             * Strip all metadata from image.
+             */
+            strip?: boolean
+            /**
+             * Background value.
+             */
+            background?: ArrayConstant
+            /**
+             * Set page height for multipage save.
+             */
+            page_height?: number
+        }): void;
+
+        /**
+         * Premultiply image alpha.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        premultiply(options?: {
+            /**
+             * Maximum value of alpha channel.
+             */
+            max_alpha?: number
+        }): Image;
+
+        /**
+         * Resample an image with a quadratic transform.
+         * @param coeff Coefficient matrix.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        quadratic(coeff: Image | ArrayConstant, options?: {
+            /**
+             * Interpolate values with this.
+             */
+            interpolate?: Interpolate
+        }): Image;
+
+        /**
+         * Unpack radiance coding to float rgb.
+         * @return Output image.
+         */
+        rad2float(): Image;
+
+        /**
+         * Save image to radiance file.
+         * @param filename Filename to save to.
+         * @param options Optional options.
+         */
+        radsave(filename: string, options?: {
+            /**
+             * Strip all metadata from image.
+             */
+            strip?: boolean
+            /**
+             * Background value.
+             */
+            background?: ArrayConstant
+            /**
+             * Set page height for multipage save.
+             */
+            page_height?: number
+        }): void;
+
+        /**
+         * Save image to radiance buffer.
+         * @param options Optional options.
+         * @return Buffer to save to.
+         */
+        radsaveBuffer(options?: {
+            /**
+             * Strip all metadata from image.
+             */
+            strip?: boolean
+            /**
+             * Background value.
+             */
+            background?: ArrayConstant
+            /**
+             * Set page height for multipage save.
+             */
+            page_height?: number
+        }): Uint8Array;
+
+        /**
+         * Save image to radiance target.
+         * @param target Target to save to.
+         * @param options Optional options.
+         */
+        radsaveTarget(target: Target, options?: {
+            /**
+             * Strip all metadata from image.
+             */
+            strip?: boolean
+            /**
+             * Background value.
+             */
+            background?: ArrayConstant
+            /**
+             * Set page height for multipage save.
+             */
+            page_height?: number
+        }): void;
+
+        /**
+         * Rank filter.
+         * @param width Window width in pixels.
+         * @param height Window height in pixels.
+         * @param index Select pixel at index.
+         * @return Output image.
+         */
+        rank(width: number, height: number, index: number): Image;
+
+        /**
+         * Save image to raw file.
+         * @param filename Filename to save to.
+         * @param options Optional options.
+         */
+        rawsave(filename: string, options?: {
+            /**
+             * Strip all metadata from image.
+             */
+            strip?: boolean
+            /**
+             * Background value.
+             */
+            background?: ArrayConstant
+            /**
+             * Set page height for multipage save.
+             */
+            page_height?: number
+        }): void;
+
+        /**
+         * Write raw image to file descriptor.
+         * @param fd File descriptor to write to.
+         * @param options Optional options.
+         */
+        rawsaveFd(fd: number, options?: {
+            /**
+             * Strip all metadata from image.
+             */
+            strip?: boolean
+            /**
+             * Background value.
+             */
+            background?: ArrayConstant
+            /**
+             * Set page height for multipage save.
+             */
+            page_height?: number
+        }): void;
+
+        /**
+         * Linear recombination with matrix.
+         * @param m matrix of coefficients.
+         * @return Output image.
+         */
+        recomb(m: Image | ArrayConstant): Image;
+
+        /**
+         * Reduce an image.
+         * @param hshrink Horizontal shrink factor.
+         * @param vshrink Vertical shrink factor.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        reduce(hshrink: number, vshrink: number, options?: {
+            /**
+             * Resampling kernel.
+             */
+            kernel?: Kernel | Enum
+        }): Image;
+
+        /**
+         * Shrink an image horizontally.
+         * @param hshrink Horizontal shrink factor.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        reduceh(hshrink: number, options?: {
+            /**
+             * Resampling kernel.
+             */
+            kernel?: Kernel | Enum
+        }): Image;
+
+        /**
+         * Shrink an image vertically.
+         * @param vshrink Vertical shrink factor.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        reducev(vshrink: number, options?: {
+            /**
+             * Resampling kernel.
+             */
+            kernel?: Kernel | Enum
+        }): Image;
+
+        /**
+         * Relational operation on two images.
+         * @param right Right-hand image argument.
+         * @param relational relational to perform.
+         * @return Output image.
+         */
+        relational(right: Image | ArrayConstant, relational: OperationRelational | Enum): Image;
+
+        /**
+         * Remainder after integer division of two images.
+         * @param right Right-hand image argument.
+         * @return Output image.
+         */
+        remainder(right: Image | ArrayConstant): Image;
+
+        /**
+         * Replicate an image.
+         * @param across Repeat this many times horizontally.
+         * @param down Repeat this many times vertically.
+         * @return Output image.
+         */
+        replicate(across: number, down: number): Image;
+
+        /**
+         * Resize an image.
+         * @param scale Scale image by this factor.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        resize(scale: number, options?: {
+            /**
+             * Resampling kernel.
+             */
+            kernel?: Kernel | Enum
+            /**
+             * Vertical scale image by this factor.
+             */
+            vscale?: number
+        }): Image;
+
+        /**
+         * Rotate an image.
+         * @param angle Angle to rotate image.
+         * @return Output image.
+         */
+        rot(angle: Angle | Enum): Image;
+
+        /**
+         * Rotate an image.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        rot45(options?: {
+            /**
+             * Angle to rotate image.
+             */
+            angle?: Angle45 | Enum
+        }): Image;
+
+        /**
+         * Rotate an image by a number of degrees.
+         * @param angle Rotate anticlockwise by this many degrees.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        rotate(angle: number, options?: {
+            /**
+             * Interpolate pixels with this.
+             */
+            interpolate?: Interpolate
+            /**
+             * Background value.
+             */
+            background?: ArrayConstant
+            /**
+             * Horizontal output displacement.
+             */
+            odx?: number
+            /**
+             * Vertical output displacement.
+             */
+            ody?: number
+            /**
+             * Horizontal input displacement.
+             */
+            idx?: number
+            /**
+             * Vertical input displacement.
+             */
+            idy?: number
+        }): Image;
+
+        /**
+         * Perform a round function on an image.
+         * @param round rounding operation to perform.
+         * @return Output image.
+         */
+        round(round: OperationRound | Enum): Image;
+
+        /**
+         * Transform srgb to hsv.
+         * @return Output image.
+         */
+        sRGB2HSV(): Image;
+
+        /**
+         * Convert an srgb image to scrgb.
+         * @return Output image.
+         */
+        sRGB2scRGB(): Image;
+
+        /**
+         * Convert scrgb to bw.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        scRGB2BW(options?: {
+            /**
+             * Output device space depth in bits.
+             */
+            depth?: number
+        }): Image;
+
+        /**
+         * Transform scrgb to xyz.
+         * @return Output image.
+         */
+        scRGB2XYZ(): Image;
+
+        /**
+         * Convert an scrgb image to srgb.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        scRGB2sRGB(options?: {
+            /**
+             * Output device space depth in bits.
+             */
+            depth?: number
+        }): Image;
+
+        /**
+         * Scale an image to uchar.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        scale(options?: {
+            /**
+             * Exponent for log scale.
+             */
+            exp?: number
+            /**
+             * Log scale.
+             */
+            log?: boolean
+        }): Image;
+
+        /**
+         * Check sequential access.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        sequential(options?: {
+            /**
+             * Tile height in pixels.
+             */
+            tile_height?: number
+        }): Image;
+
+        /**
+         * Unsharp masking for print.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        sharpen(options?: {
+            /**
+             * Sigma of gaussian.
+             */
+            sigma?: number
+            /**
+             * Flat/jaggy threshold.
+             */
+            x1?: number
+            /**
+             * Maximum brightening.
+             */
+            y2?: number
+            /**
+             * Maximum darkening.
+             */
+            y3?: number
+            /**
+             * Slope for flat areas.
+             */
+            m1?: number
+            /**
+             * Slope for jaggy areas.
+             */
+            m2?: number
+        }): Image;
+
+        /**
+         * Shrink an image.
+         * @param hshrink Horizontal shrink factor.
+         * @param vshrink Vertical shrink factor.
+         * @return Output image.
+         */
+        shrink(hshrink: number, vshrink: number): Image;
+
+        /**
+         * Shrink an image horizontally.
+         * @param hshrink Horizontal shrink factor.
+         * @return Output image.
+         */
+        shrinkh(hshrink: number): Image;
+
+        /**
+         * Shrink an image vertically.
+         * @param vshrink Vertical shrink factor.
+         * @return Output image.
+         */
+        shrinkv(vshrink: number): Image;
+
+        /**
+         * Unit vector of pixel.
+         * @return Output image.
+         */
+        sign(): Image;
+
+        /**
+         * Similarity transform of an image.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        similarity(options?: {
+            /**
+             * Scale by this factor.
+             */
+            scale?: number
+            /**
+             * Rotate anticlockwise by this many degrees.
+             */
+            angle?: number
+            /**
+             * Interpolate pixels with this.
+             */
+            interpolate?: Interpolate
+            /**
+             * Background value.
+             */
+            background?: ArrayConstant
+            /**
+             * Horizontal output displacement.
+             */
+            odx?: number
+            /**
+             * Vertical output displacement.
+             */
+            ody?: number
+            /**
+             * Horizontal input displacement.
+             */
+            idx?: number
+            /**
+             * Vertical input displacement.
+             */
+            idy?: number
+        }): Image;
+
+        /**
+         * Extract an area from an image.
+         * @param width Width of extract area.
+         * @param height Height of extract area.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        smartcrop(width: number, height: number, options?: {
+            /**
+             * How to measure interestingness.
+             */
+            interesting?: Interesting | Enum
+        }): Image;
+
+        /**
+         * Sobel edge detector.
+         * @return Output image.
+         */
+        sobel(): Image;
+
+        /**
+         * Spatial correlation.
+         * @param ref Input reference image.
+         * @return Output image.
+         */
+        spcor(ref: Image | ArrayConstant): Image;
+
+        /**
+         * Make displayable power spectrum.
+         * @return Output image.
+         */
+        spectrum(): Image;
+
+        /**
+         * Find many image stats.
+         * @return Output array of statistics.
+         */
+        stats(): Image;
+
+        /**
+         * Statistical difference.
+         * @param width Window width in pixels.
+         * @param height Window height in pixels.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        stdif(width: number, height: number, options?: {
+            /**
+             * New deviation.
+             */
+            s0?: number
+            /**
+             * Weight of new deviation.
+             */
+            b?: number
+            /**
+             * New mean.
+             */
+            m0?: number
+            /**
+             * Weight of new mean.
+             */
+            a?: number
+        }): Image;
+
+        /**
+         * Subsample an image.
+         * @param xfac Horizontal subsample factor.
+         * @param yfac Vertical subsample factor.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        subsample(xfac: number, yfac: number, options?: {
+            /**
+             * Point sample.
+             */
+            point?: boolean
+        }): Image;
+
+        /**
+         * Subtract two images.
+         * @param right Right-hand image argument.
+         * @return Output image.
+         */
+        subtract(right: Image | ArrayConstant): Image;
+
+        /**
+         * Generate thumbnail from image.
+         * @param width Size to this width.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        thumbnailImage(width: number, options?: {
+            /**
+             * Size to this height.
+             */
+            height?: number
+            /**
+             * Only upsize, only downsize, or both.
+             */
+            size?: Size | Enum
+            /**
+             * Don't use orientation tags to rotate image upright.
+             */
+            no_rotate?: boolean
+            /**
+             * Reduce to fill target rectangle, then crop.
+             */
+            crop?: Interesting | Enum
+            /**
+             * Reduce in linear light.
+             */
+            linear?: boolean
+            /**
+             * Fallback import profile.
+             */
+            import_profile?: string
+            /**
+             * Fallback export profile.
+             */
+            export_profile?: string
+            /**
+             * Rendering intent.
+             */
+            intent?: Intent | Enum
+        }): Image;
+
+        /**
+         * Save image to tiff file.
+         * @param filename Filename to save to.
+         * @param options Optional options.
+         */
+        tiffsave(filename: string, options?: {
+            /**
+             * Compression for this file.
+             */
+            compression?: ForeignTiffCompression | Enum
+            /**
+             * Q factor.
+             */
+            Q?: number
+            /**
+             * Compression prediction.
+             */
+            predictor?: ForeignTiffPredictor | Enum
+            /**
+             * Icc profile to embed.
+             */
+            profile?: string
+            /**
+             * Write a tiled tiff.
+             */
+            tile?: boolean
+            /**
+             * Tile width in pixels.
+             */
+            tile_width?: number
+            /**
+             * Tile height in pixels.
+             */
+            tile_height?: number
+            /**
+             * Write a pyramidal tiff.
+             */
+            pyramid?: boolean
+            /**
+             * Use 0 for white in 1-bit images.
+             */
+            miniswhite?: boolean
+            /**
+             * Write as a 1, 2, 4 or 8 bit image.
+             */
+            bitdepth?: number
+            /**
+             * Resolution unit.
+             */
+            resunit?: ForeignTiffResunit | Enum
+            /**
+             * Horizontal resolution in pixels/mm.
+             */
+            xres?: number
+            /**
+             * Vertical resolution in pixels/mm.
+             */
+            yres?: number
+            /**
+             * Write a bigtiff image.
+             */
+            bigtiff?: boolean
+            /**
+             * Write a properties document to imagedescription.
+             */
+            properties?: boolean
+            /**
+             * Method to shrink regions.
+             */
+            region_shrink?: RegionShrink | Enum
+            /**
+             * Zstd compression level.
+             */
+            level?: number
+            /**
+             * Enable webp lossless mode.
+             */
+            lossless?: boolean
+            /**
+             * Pyramid depth.
+             */
+            depth?: ForeignDzDepth | Enum
+            /**
+             * Save pyr layers as sub-ifds.
+             */
+            subifd?: boolean
+            /**
+             * Save with premultiplied alpha.
+             */
+            premultiply?: boolean
+            /**
+             * Strip all metadata from image.
+             */
+            strip?: boolean
+            /**
+             * Background value.
+             */
+            background?: ArrayConstant
+            /**
+             * Set page height for multipage save.
+             */
+            page_height?: number
+        }): void;
+
+        /**
+         * Save image to tiff buffer.
+         * @param options Optional options.
+         * @return Buffer to save to.
+         */
+        tiffsaveBuffer(options?: {
+            /**
+             * Compression for this file.
+             */
+            compression?: ForeignTiffCompression | Enum
+            /**
+             * Q factor.
+             */
+            Q?: number
+            /**
+             * Compression prediction.
+             */
+            predictor?: ForeignTiffPredictor | Enum
+            /**
+             * Icc profile to embed.
+             */
+            profile?: string
+            /**
+             * Write a tiled tiff.
+             */
+            tile?: boolean
+            /**
+             * Tile width in pixels.
+             */
+            tile_width?: number
+            /**
+             * Tile height in pixels.
+             */
+            tile_height?: number
+            /**
+             * Write a pyramidal tiff.
+             */
+            pyramid?: boolean
+            /**
+             * Use 0 for white in 1-bit images.
+             */
+            miniswhite?: boolean
+            /**
+             * Write as a 1, 2, 4 or 8 bit image.
+             */
+            bitdepth?: number
+            /**
+             * Resolution unit.
+             */
+            resunit?: ForeignTiffResunit | Enum
+            /**
+             * Horizontal resolution in pixels/mm.
+             */
+            xres?: number
+            /**
+             * Vertical resolution in pixels/mm.
+             */
+            yres?: number
+            /**
+             * Write a bigtiff image.
+             */
+            bigtiff?: boolean
+            /**
+             * Write a properties document to imagedescription.
+             */
+            properties?: boolean
+            /**
+             * Method to shrink regions.
+             */
+            region_shrink?: RegionShrink | Enum
+            /**
+             * Zstd compression level.
+             */
+            level?: number
+            /**
+             * Enable webp lossless mode.
+             */
+            lossless?: boolean
+            /**
+             * Pyramid depth.
+             */
+            depth?: ForeignDzDepth | Enum
+            /**
+             * Save pyr layers as sub-ifds.
+             */
+            subifd?: boolean
+            /**
+             * Save with premultiplied alpha.
+             */
+            premultiply?: boolean
+            /**
+             * Strip all metadata from image.
+             */
+            strip?: boolean
+            /**
+             * Background value.
+             */
+            background?: ArrayConstant
+            /**
+             * Set page height for multipage save.
+             */
+            page_height?: number
+        }): Uint8Array;
+
+        /**
+         * Cache an image as a set of tiles.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        tilecache(options?: {
+            /**
+             * Tile width in pixels.
+             */
+            tile_width?: number
+            /**
+             * Tile height in pixels.
+             */
+            tile_height?: number
+            /**
+             * Maximum number of tiles to cache.
+             */
+            max_tiles?: number
+            /**
+             * Expected access pattern.
+             */
+            access?: Access | Enum
+            /**
+             * Allow threaded access.
+             */
+            threaded?: boolean
+            /**
+             * Keep cache between evaluations.
+             */
+            persistent?: boolean
+        }): Image;
+
+        /**
+         * Transpose3d an image.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        transpose3d(options?: {
+            /**
+             * Height of each input page.
+             */
+            page_height?: number
+        }): Image;
+
+        /**
+         * Unpremultiply image alpha.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        unpremultiply(options?: {
+            /**
+             * Maximum value of alpha channel.
+             */
+            max_alpha?: number
+            /**
+             * Unpremultiply with this alpha.
+             */
+            alpha_band?: number
+        }): Image;
+
+        /**
+         * Save image to file in vips format.
+         * @param filename Filename to save to.
+         * @param options Optional options.
+         */
+        vipssave(filename: string, options?: {
+            /**
+             * Strip all metadata from image.
+             */
+            strip?: boolean
+            /**
+             * Background value.
+             */
+            background?: ArrayConstant
+            /**
+             * Set page height for multipage save.
+             */
+            page_height?: number
+        }): void;
+
+        /**
+         * Save image to target in vips format.
+         * @param target Target to save to.
+         * @param options Optional options.
+         */
+        vipssaveTarget(target: Target, options?: {
+            /**
+             * Strip all metadata from image.
+             */
+            strip?: boolean
+            /**
+             * Background value.
+             */
+            background?: ArrayConstant
+            /**
+             * Set page height for multipage save.
+             */
+            page_height?: number
+        }): void;
+
+        /**
+         * Save image to webp file.
+         * @param filename Filename to save to.
+         * @param options Optional options.
+         */
+        webpsave(filename: string, options?: {
+            /**
+             * Q factor.
+             */
+            Q?: number
+            /**
+             * Enable lossless compression.
+             */
+            lossless?: boolean
+            /**
+             * Preset for lossy compression.
+             */
+            preset?: ForeignWebpPreset | Enum
+            /**
+             * Enable high quality chroma subsampling.
+             */
+            smart_subsample?: boolean
+            /**
+             * Enable preprocessing in lossless mode (uses q).
+             */
+            near_lossless?: boolean
+            /**
+             * Change alpha plane fidelity for lossy compression.
+             */
+            alpha_q?: number
+            /**
+             * Optimise for minium size.
+             */
+            min_size?: boolean
+            /**
+             * Minimum number of frames between key frames.
+             */
+            kmin?: number
+            /**
+             * Maximum number of frames between key frames.
+             */
+            kmax?: number
+            /**
+             * Level of cpu effort to reduce file size.
+             */
+            effort?: number
+            /**
+             * Icc profile to embed.
+             */
+            profile?: string
+            /**
+             * Strip all metadata from image.
+             */
+            strip?: boolean
+            /**
+             * Background value.
+             */
+            background?: ArrayConstant
+            /**
+             * Set page height for multipage save.
+             */
+            page_height?: number
+        }): void;
+
+        /**
+         * Save image to webp buffer.
+         * @param options Optional options.
+         * @return Buffer to save to.
+         */
+        webpsaveBuffer(options?: {
+            /**
+             * Q factor.
+             */
+            Q?: number
+            /**
+             * Enable lossless compression.
+             */
+            lossless?: boolean
+            /**
+             * Preset for lossy compression.
+             */
+            preset?: ForeignWebpPreset | Enum
+            /**
+             * Enable high quality chroma subsampling.
+             */
+            smart_subsample?: boolean
+            /**
+             * Enable preprocessing in lossless mode (uses q).
+             */
+            near_lossless?: boolean
+            /**
+             * Change alpha plane fidelity for lossy compression.
+             */
+            alpha_q?: number
+            /**
+             * Optimise for minium size.
+             */
+            min_size?: boolean
+            /**
+             * Minimum number of frames between key frames.
+             */
+            kmin?: number
+            /**
+             * Maximum number of frames between key frames.
+             */
+            kmax?: number
+            /**
+             * Level of cpu effort to reduce file size.
+             */
+            effort?: number
+            /**
+             * Icc profile to embed.
+             */
+            profile?: string
+            /**
+             * Strip all metadata from image.
+             */
+            strip?: boolean
+            /**
+             * Background value.
+             */
+            background?: ArrayConstant
+            /**
+             * Set page height for multipage save.
+             */
+            page_height?: number
+        }): Uint8Array;
+
+        /**
+         * Save image to webp target.
+         * @param target Target to save to.
+         * @param options Optional options.
+         */
+        webpsaveTarget(target: Target, options?: {
+            /**
+             * Q factor.
+             */
+            Q?: number
+            /**
+             * Enable lossless compression.
+             */
+            lossless?: boolean
+            /**
+             * Preset for lossy compression.
+             */
+            preset?: ForeignWebpPreset | Enum
+            /**
+             * Enable high quality chroma subsampling.
+             */
+            smart_subsample?: boolean
+            /**
+             * Enable preprocessing in lossless mode (uses q).
+             */
+            near_lossless?: boolean
+            /**
+             * Change alpha plane fidelity for lossy compression.
+             */
+            alpha_q?: number
+            /**
+             * Optimise for minium size.
+             */
+            min_size?: boolean
+            /**
+             * Minimum number of frames between key frames.
+             */
+            kmin?: number
+            /**
+             * Maximum number of frames between key frames.
+             */
+            kmax?: number
+            /**
+             * Level of cpu effort to reduce file size.
+             */
+            effort?: number
+            /**
+             * Icc profile to embed.
+             */
+            profile?: string
+            /**
+             * Strip all metadata from image.
+             */
+            strip?: boolean
+            /**
+             * Background value.
+             */
+            background?: ArrayConstant
+            /**
+             * Set page height for multipage save.
+             */
+            page_height?: number
+        }): void;
+
+        /**
+         * Wrap image origin.
+         * @param options Optional options.
+         * @return Output image.
+         */
+        wrap(options?: {
+            /**
+             * Left edge of input in output.
+             */
+            x?: number
+            /**
+             * Top edge of input in output.
+             */
+            y?: number
+        }): Image;
+
+        /**
+         * Zoom an image.
+         * @param xfac Horizontal zoom factor.
+         * @param yfac Vertical zoom factor.
+         * @return Output image.
+         */
+        zoom(xfac: number, yfac: number): Image;
+    }
+}
\ No newline at end of file