@types/gm

  • Version 1.18.12
  • Published
  • 24.1 kB
  • 1 dependency
  • MIT license

Install

npm i @types/gm
yarn add @types/gm
pnpm add @types/gm

Overview

TypeScript definitions for gm

Index

Functions

Interfaces

Type Aliases

Functions

function compare

compare: {
(filename1: string, filename2: string, callback: CompareCallback): void;
(
filename1: string,
filename2: string,
options: number | CompareOptions,
callback: CompareCallback
): void;
};

    function m

    m: typeof m;

      function subClass

      subClass: (options: ClassOptions) => SubClass;

        Interfaces

        interface ChannelInfo

        interface ChannelInfo<T> {}

          property Blue

          Blue: T;

            property Green

            Green: T;

              property Red

              Red: T;

                interface ClassOptions

                interface ClassOptions {}

                  property appPath

                  appPath?: string | undefined;

                    property imageMagick

                    imageMagick?: boolean | undefined;

                      property nativeAutoOrient

                      nativeAutoOrient?: boolean | undefined;

                        property timeout

                        timeout?: string | number;

                          interface ColorStatistics

                          interface ColorStatistics {}

                            property 'Standard Deviation'

                            'Standard Deviation': string;

                              property Maximum

                              Maximum: string;

                                property Mean

                                Mean: string;

                                  property Minimum

                                  Minimum: string;

                                    interface CompareOptions

                                    interface CompareOptions {}

                                      property file

                                      file?: string | undefined;

                                        property highlightColor

                                        highlightColor?: string | undefined;

                                          property highlightStyle

                                          highlightStyle?: HighlightStyle | undefined;

                                            property tolerance

                                            tolerance?: number | undefined;

                                              interface Dimensions

                                              interface Dimensions {}

                                                property height

                                                height: number;

                                                  property width

                                                  width: number;

                                                    interface GetterOptions

                                                    interface GetterOptions {}

                                                      property bufferStream

                                                      bufferStream?: boolean | undefined;

                                                        interface ImageInfo

                                                        interface ImageInfo {}

                                                          property 'Background Color'

                                                          'Background Color': string;

                                                            property 'Border Color'

                                                            'Border Color': string;

                                                              property 'Channel Depths'

                                                              'Channel Depths': ChannelInfo<string>;

                                                                property 'Channel Statistics'

                                                                'Channel Statistics': ChannelInfo<ColorStatistics>;

                                                                  property 'JPEG-Colorspace-Name'

                                                                  'JPEG-Colorspace-Name'?: string | undefined;

                                                                    property 'JPEG-Colorspace'

                                                                    'JPEG-Colorspace'?: string | undefined;

                                                                      property 'JPEG-Quality'

                                                                      'JPEG-Quality'?: string | undefined;

                                                                        property 'JPEG-Sampling-factors'

                                                                        'JPEG-Sampling-factors'?: string | undefined;

                                                                          property 'Matte Color'

                                                                          'Matte Color': string;

                                                                            property 'Page geometry'

                                                                            'Page geometry': string;

                                                                              property 'Profile-color'

                                                                              'Profile-color'?: string | undefined;

                                                                                property 'Profile-EXIF'

                                                                                'Profile-EXIF'?:
                                                                                | {
                                                                                [key: string]: string;
                                                                                }
                                                                                | undefined;

                                                                                  property 'Profile-iptc'

                                                                                  'Profile-iptc'?:
                                                                                  | {
                                                                                  [key: string]: string;
                                                                                  }
                                                                                  | undefined;

                                                                                    property 'Profile-XMP'

                                                                                    'Profile-XMP'?: string | undefined;

                                                                                      property Class

                                                                                      Class: string;

                                                                                        property color

                                                                                        color: number;

                                                                                          property Compose

                                                                                          Compose: string;

                                                                                            property Compression

                                                                                            Compression: string;

                                                                                              property depth

                                                                                              depth: number;

                                                                                                property Depth

                                                                                                Depth: string;

                                                                                                  property Dispose

                                                                                                  Dispose: string;

                                                                                                    property Filesize

                                                                                                    Filesize: string;

                                                                                                      property format

                                                                                                      format: string;

                                                                                                        property Format

                                                                                                        Format: string;

                                                                                                          property Geometry

                                                                                                          Geometry: string;

                                                                                                            property Interlace

                                                                                                            Interlace: string;

                                                                                                              property Iterations

                                                                                                              Iterations: string;

                                                                                                                property Orientation

                                                                                                                Orientation: string;

                                                                                                                  property path

                                                                                                                  path: string;

                                                                                                                    property Resolution

                                                                                                                    Resolution?: string | undefined;

                                                                                                                      property Signature

                                                                                                                      Signature: string;

                                                                                                                        property size

                                                                                                                        size: Dimensions;

                                                                                                                          property Software

                                                                                                                          Software: string;

                                                                                                                            property Tainted

                                                                                                                            Tainted: string;

                                                                                                                              property Type

                                                                                                                              Type: string;

                                                                                                                                interface State

                                                                                                                                interface State {}

                                                                                                                                  method adjoin

                                                                                                                                  adjoin: () => State;

                                                                                                                                    method affine

                                                                                                                                    affine: (matrix: string) => State;

                                                                                                                                      method antialias

                                                                                                                                      antialias: (enable: boolean) => State;

                                                                                                                                        method append

                                                                                                                                        append: (image: string, ltr?: boolean) => State;

                                                                                                                                          method authenticate

                                                                                                                                          authenticate: (password: string) => State;

                                                                                                                                            method autoOrient

                                                                                                                                            autoOrient: () => State;

                                                                                                                                              method backdrop

                                                                                                                                              backdrop: () => State;

                                                                                                                                                method background

                                                                                                                                                background: (color: string) => State;

                                                                                                                                                  method bitdepth

                                                                                                                                                  bitdepth: (bits: number) => State;

                                                                                                                                                    method blackThreshold

                                                                                                                                                    blackThreshold: {
                                                                                                                                                    (intensity: number): State;
                                                                                                                                                    (red: number, green: number, blue: number, opacity?: number): State;
                                                                                                                                                    };

                                                                                                                                                      method bluePrimary

                                                                                                                                                      bluePrimary: (x: number, y: number) => State;

                                                                                                                                                        method blur

                                                                                                                                                        blur: (radius: number, sigma?: number) => State;

                                                                                                                                                          method border

                                                                                                                                                          border: (width: number, height: number) => State;

                                                                                                                                                            method borderColor

                                                                                                                                                            borderColor: (color: string) => State;

                                                                                                                                                              method box

                                                                                                                                                              box: (color: string) => State;

                                                                                                                                                                method channel

                                                                                                                                                                channel: (type: NamedColor | string) => State;

                                                                                                                                                                  method charcoal

                                                                                                                                                                  charcoal: (factor: number) => State;

                                                                                                                                                                    method chop

                                                                                                                                                                    chop: (width: number, height: number, x?: number, y?: number) => State;

                                                                                                                                                                      method clip

                                                                                                                                                                      clip: () => State;

                                                                                                                                                                        method coalesce

                                                                                                                                                                        coalesce: () => State;

                                                                                                                                                                          method color

                                                                                                                                                                          color: {
                                                                                                                                                                          (callback: GetterCallback<number>): State;
                                                                                                                                                                          (opts: GetterOptions, callback: GetterCallback<number>): State;
                                                                                                                                                                          };

                                                                                                                                                                            method colorize

                                                                                                                                                                            colorize: (red: number, green: number, blue: number) => State;

                                                                                                                                                                              method colorMap

                                                                                                                                                                              colorMap: (type: 'shared' | 'private' | string) => State;

                                                                                                                                                                                method colors

                                                                                                                                                                                colors: (colors: number) => State;

                                                                                                                                                                                  method colorspace

                                                                                                                                                                                  colorspace: (space: ColorSpace | string) => State;

                                                                                                                                                                                    method command

                                                                                                                                                                                    command: (customCommand: string) => State;

                                                                                                                                                                                      method compose

                                                                                                                                                                                      compose: (operator: ComposeOperator | string) => State;

                                                                                                                                                                                        method composite

                                                                                                                                                                                        composite: (changeImagePath: string, maskImagePath?: string) => State;

                                                                                                                                                                                          method compress

                                                                                                                                                                                          compress: (type: CompressionType | string) => State;

                                                                                                                                                                                            method contrast

                                                                                                                                                                                            contrast: (multiplier: number) => State;

                                                                                                                                                                                              method convolve

                                                                                                                                                                                              convolve: (kernel: string) => State;

                                                                                                                                                                                                method createDirectories

                                                                                                                                                                                                createDirectories: () => State;

                                                                                                                                                                                                  method crop

                                                                                                                                                                                                  crop: (
                                                                                                                                                                                                  width: number,
                                                                                                                                                                                                  height: number,
                                                                                                                                                                                                  x?: number,
                                                                                                                                                                                                  y?: number,
                                                                                                                                                                                                  percent?: boolean
                                                                                                                                                                                                  ) => State;

                                                                                                                                                                                                    method cycle

                                                                                                                                                                                                    cycle: (amount: number) => State;

                                                                                                                                                                                                      method deconstruct

                                                                                                                                                                                                      deconstruct: () => State;

                                                                                                                                                                                                        method define

                                                                                                                                                                                                        define: (value: string) => State;

                                                                                                                                                                                                          method delay

                                                                                                                                                                                                          delay: (milliseconds: number) => State;

                                                                                                                                                                                                            method density

                                                                                                                                                                                                            density: (width: number, height: number) => State;

                                                                                                                                                                                                              method depth

                                                                                                                                                                                                              depth: {
                                                                                                                                                                                                              (callback: GetterCallback<number>): State;
                                                                                                                                                                                                              (opts: GetterOptions, callback: GetterCallback<number>): State;
                                                                                                                                                                                                              };

                                                                                                                                                                                                                method despeckle

                                                                                                                                                                                                                despeckle: () => State;

                                                                                                                                                                                                                  method displace

                                                                                                                                                                                                                  displace: (horizontal: number, vertical: number) => State;

                                                                                                                                                                                                                    method display

                                                                                                                                                                                                                    display: (xServer: string) => State;

                                                                                                                                                                                                                      method dispose

                                                                                                                                                                                                                      dispose: (method: DisposeMethod | string) => State;

                                                                                                                                                                                                                        method dissolve

                                                                                                                                                                                                                        dissolve: (percent: number) => State;

                                                                                                                                                                                                                          method dither

                                                                                                                                                                                                                          dither: (enable?: boolean) => State;

                                                                                                                                                                                                                            method draw

                                                                                                                                                                                                                            draw: (args: string) => State;

                                                                                                                                                                                                                              method drawArc

                                                                                                                                                                                                                              drawArc: (
                                                                                                                                                                                                                              x0: number,
                                                                                                                                                                                                                              y0: number,
                                                                                                                                                                                                                              x1: number,
                                                                                                                                                                                                                              y1: number,
                                                                                                                                                                                                                              r0: number,
                                                                                                                                                                                                                              r1: number
                                                                                                                                                                                                                              ) => State;

                                                                                                                                                                                                                                method drawBezier

                                                                                                                                                                                                                                drawBezier: (
                                                                                                                                                                                                                                coord0: [number, number],
                                                                                                                                                                                                                                coord1: [number, number],
                                                                                                                                                                                                                                ...coords: Array<[number, number]>
                                                                                                                                                                                                                                ) => State;

                                                                                                                                                                                                                                  method drawCircle

                                                                                                                                                                                                                                  drawCircle: (x0: number, y0: number, x1: number, y1: number) => State;

                                                                                                                                                                                                                                    method drawEllipse

                                                                                                                                                                                                                                    drawEllipse: (
                                                                                                                                                                                                                                    x0: number,
                                                                                                                                                                                                                                    y0: number,
                                                                                                                                                                                                                                    rx: number,
                                                                                                                                                                                                                                    ry: number,
                                                                                                                                                                                                                                    a0: number,
                                                                                                                                                                                                                                    a1: number
                                                                                                                                                                                                                                    ) => State;

                                                                                                                                                                                                                                      method drawLine

                                                                                                                                                                                                                                      drawLine: (x0: number, y0: number, x1: number, y1: number) => State;

                                                                                                                                                                                                                                        method drawPoint

                                                                                                                                                                                                                                        drawPoint: (x: number, y: number) => State;

                                                                                                                                                                                                                                          method drawPolygon

                                                                                                                                                                                                                                          drawPolygon: (
                                                                                                                                                                                                                                          coord0: [number, number],
                                                                                                                                                                                                                                          coord1: [number, number],
                                                                                                                                                                                                                                          coord2: [number, number],
                                                                                                                                                                                                                                          ...coords: Array<[number, number]>
                                                                                                                                                                                                                                          ) => State;

                                                                                                                                                                                                                                            method drawPolyline

                                                                                                                                                                                                                                            drawPolyline: (
                                                                                                                                                                                                                                            coord0: [number, number],
                                                                                                                                                                                                                                            coord1: [number, number],
                                                                                                                                                                                                                                            coord2: [number, number],
                                                                                                                                                                                                                                            ...coords: Array<[number, number]>
                                                                                                                                                                                                                                            ) => State;

                                                                                                                                                                                                                                              method drawRectangle

                                                                                                                                                                                                                                              drawRectangle: (
                                                                                                                                                                                                                                              x0: number,
                                                                                                                                                                                                                                              y0: number,
                                                                                                                                                                                                                                              x1: number,
                                                                                                                                                                                                                                              y1: number,
                                                                                                                                                                                                                                              wc?: number,
                                                                                                                                                                                                                                              hc?: number
                                                                                                                                                                                                                                              ) => State;

                                                                                                                                                                                                                                                method drawText

                                                                                                                                                                                                                                                drawText: (
                                                                                                                                                                                                                                                x: number,
                                                                                                                                                                                                                                                y: number,
                                                                                                                                                                                                                                                text: string,
                                                                                                                                                                                                                                                gravity?: GravityDirection | string
                                                                                                                                                                                                                                                ) => State;

                                                                                                                                                                                                                                                  method edge

                                                                                                                                                                                                                                                  edge: (radius?: number) => State;

                                                                                                                                                                                                                                                    method emboss

                                                                                                                                                                                                                                                    emboss: (radius?: number) => State;

                                                                                                                                                                                                                                                      method encoding

                                                                                                                                                                                                                                                      encoding: (encoding: Encoding | string) => State;

                                                                                                                                                                                                                                                        method endian

                                                                                                                                                                                                                                                        endian: (type: EndianType | string) => State;

                                                                                                                                                                                                                                                          method enhance

                                                                                                                                                                                                                                                          enhance: () => State;

                                                                                                                                                                                                                                                            method equalize

                                                                                                                                                                                                                                                            equalize: () => State;

                                                                                                                                                                                                                                                              method extent

                                                                                                                                                                                                                                                              extent: (width: number, height: number, options?: string) => State;

                                                                                                                                                                                                                                                                method file

                                                                                                                                                                                                                                                                file: (filename: string) => State;

                                                                                                                                                                                                                                                                  method filesize

                                                                                                                                                                                                                                                                  filesize: {
                                                                                                                                                                                                                                                                  (callback: GetterCallback<string>): State;
                                                                                                                                                                                                                                                                  (opts: GetterOptions, callback: GetterCallback<string>): State;
                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                    method fill

                                                                                                                                                                                                                                                                    fill: (color: string) => State;

                                                                                                                                                                                                                                                                      method filter

                                                                                                                                                                                                                                                                      filter: (type: FilterType | string) => State;

                                                                                                                                                                                                                                                                        method flatten

                                                                                                                                                                                                                                                                        flatten: () => State;

                                                                                                                                                                                                                                                                          method flip

                                                                                                                                                                                                                                                                          flip: () => State;

                                                                                                                                                                                                                                                                            method flop

                                                                                                                                                                                                                                                                            flop: () => State;

                                                                                                                                                                                                                                                                              method font

                                                                                                                                                                                                                                                                              font: (name: string, size?: number) => State;

                                                                                                                                                                                                                                                                                method fontSize

                                                                                                                                                                                                                                                                                fontSize: (size: number) => State;

                                                                                                                                                                                                                                                                                  method foreground

                                                                                                                                                                                                                                                                                  foreground: (color: string) => State;

                                                                                                                                                                                                                                                                                    method format

                                                                                                                                                                                                                                                                                    format: {
                                                                                                                                                                                                                                                                                    (callback: GetterCallback<string>): State;
                                                                                                                                                                                                                                                                                    (opts: GetterOptions, callback: GetterCallback<string>): State;
                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                      method frame

                                                                                                                                                                                                                                                                                      frame: (
                                                                                                                                                                                                                                                                                      width: number,
                                                                                                                                                                                                                                                                                      height: number,
                                                                                                                                                                                                                                                                                      outerBevelWidth: number,
                                                                                                                                                                                                                                                                                      outBevelHeight: number
                                                                                                                                                                                                                                                                                      ) => State;

                                                                                                                                                                                                                                                                                        method fuzz

                                                                                                                                                                                                                                                                                        fuzz: (distance: number, percent?: boolean) => State;

                                                                                                                                                                                                                                                                                          method gamma

                                                                                                                                                                                                                                                                                          gamma: (r: number, g: number, b: number) => State;

                                                                                                                                                                                                                                                                                            method gaussian

                                                                                                                                                                                                                                                                                            gaussian: (radius: number, sigma?: number) => State;

                                                                                                                                                                                                                                                                                              method geometry

                                                                                                                                                                                                                                                                                              geometry: {
                                                                                                                                                                                                                                                                                              (width: number, height?: number, option?: ResizeOption): State;
                                                                                                                                                                                                                                                                                              (geometry: string): State;
                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                method gravity

                                                                                                                                                                                                                                                                                                gravity: (direction: GravityDirection | string) => State;

                                                                                                                                                                                                                                                                                                  method greenPrimary

                                                                                                                                                                                                                                                                                                  greenPrimary: (x: number, y: number) => State;

                                                                                                                                                                                                                                                                                                    method highlightColor

                                                                                                                                                                                                                                                                                                    highlightColor: (color: string) => State;

                                                                                                                                                                                                                                                                                                      method highlightStyle

                                                                                                                                                                                                                                                                                                      highlightStyle: (style: HighlightStyle | string) => State;

                                                                                                                                                                                                                                                                                                        method iconGeometry

                                                                                                                                                                                                                                                                                                        iconGeometry: (geometry: string) => State;

                                                                                                                                                                                                                                                                                                          method identify

                                                                                                                                                                                                                                                                                                          identify: {
                                                                                                                                                                                                                                                                                                          (callback: GetterCallback<ImageInfo>): State;
                                                                                                                                                                                                                                                                                                          (format: string, callback: GetterCallback<string>): State;
                                                                                                                                                                                                                                                                                                          (opts: GetterOptions, callback: GetterCallback<ImageInfo>): State;
                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                            method implode

                                                                                                                                                                                                                                                                                                            implode: (factor?: number) => State;

                                                                                                                                                                                                                                                                                                              method in

                                                                                                                                                                                                                                                                                                              in: (...customArguments: string[]) => State;

                                                                                                                                                                                                                                                                                                                method intent

                                                                                                                                                                                                                                                                                                                intent: (type: IntentType | string) => State;

                                                                                                                                                                                                                                                                                                                  method interlace

                                                                                                                                                                                                                                                                                                                  interlace: (type: InterlaceType | string) => State;

                                                                                                                                                                                                                                                                                                                    method label

                                                                                                                                                                                                                                                                                                                    label: (name: string) => State;

                                                                                                                                                                                                                                                                                                                      method lat

                                                                                                                                                                                                                                                                                                                      lat: (width: number, height: number, offset: number, percent?: boolean) => State;

                                                                                                                                                                                                                                                                                                                        method level

                                                                                                                                                                                                                                                                                                                        level: (
                                                                                                                                                                                                                                                                                                                        blackPoint: number,
                                                                                                                                                                                                                                                                                                                        gamma: number,
                                                                                                                                                                                                                                                                                                                        whitePoint: number,
                                                                                                                                                                                                                                                                                                                        percent?: boolean
                                                                                                                                                                                                                                                                                                                        ) => State;

                                                                                                                                                                                                                                                                                                                          method limit

                                                                                                                                                                                                                                                                                                                          limit: (type: LimitType | string, val: string) => State;

                                                                                                                                                                                                                                                                                                                            method list

                                                                                                                                                                                                                                                                                                                            list: (type: ListType | string) => State;

                                                                                                                                                                                                                                                                                                                              method log

                                                                                                                                                                                                                                                                                                                              log: (format: string) => State;

                                                                                                                                                                                                                                                                                                                                method loop

                                                                                                                                                                                                                                                                                                                                loop: (iterations: number) => State;

                                                                                                                                                                                                                                                                                                                                  method lower

                                                                                                                                                                                                                                                                                                                                  lower: (width: number, height: number) => State;

                                                                                                                                                                                                                                                                                                                                    method magnify

                                                                                                                                                                                                                                                                                                                                    magnify: (factor: number) => State;

                                                                                                                                                                                                                                                                                                                                      method map

                                                                                                                                                                                                                                                                                                                                      map: (filename: string) => State;

                                                                                                                                                                                                                                                                                                                                        method mask

                                                                                                                                                                                                                                                                                                                                        mask: (filename: string) => State;

                                                                                                                                                                                                                                                                                                                                          method matte

                                                                                                                                                                                                                                                                                                                                          matte: () => State;

                                                                                                                                                                                                                                                                                                                                            method matteColor

                                                                                                                                                                                                                                                                                                                                            matteColor: (color: string) => State;

                                                                                                                                                                                                                                                                                                                                              method maximumError

                                                                                                                                                                                                                                                                                                                                              maximumError: (limit: number) => State;

                                                                                                                                                                                                                                                                                                                                                method median

                                                                                                                                                                                                                                                                                                                                                median: (radius?: number) => State;

                                                                                                                                                                                                                                                                                                                                                  method minify

                                                                                                                                                                                                                                                                                                                                                  minify: (factor: number) => State;

                                                                                                                                                                                                                                                                                                                                                    method mode

                                                                                                                                                                                                                                                                                                                                                    mode: (mode: OperationMode | string) => State;

                                                                                                                                                                                                                                                                                                                                                      method modulate

                                                                                                                                                                                                                                                                                                                                                      modulate: (b: number, s?: number, h?: number) => State;

                                                                                                                                                                                                                                                                                                                                                        method monitor

                                                                                                                                                                                                                                                                                                                                                        monitor: () => State;

                                                                                                                                                                                                                                                                                                                                                          method monochrome

                                                                                                                                                                                                                                                                                                                                                          monochrome: () => State;

                                                                                                                                                                                                                                                                                                                                                            method montage

                                                                                                                                                                                                                                                                                                                                                            montage: (otherImg: string) => State;

                                                                                                                                                                                                                                                                                                                                                              method morph

                                                                                                                                                                                                                                                                                                                                                              morph: (
                                                                                                                                                                                                                                                                                                                                                              otherImg: string | string[],
                                                                                                                                                                                                                                                                                                                                                              outName: string,
                                                                                                                                                                                                                                                                                                                                                              callback?: WriteCallback
                                                                                                                                                                                                                                                                                                                                                              ) => State;

                                                                                                                                                                                                                                                                                                                                                                method mosaic

                                                                                                                                                                                                                                                                                                                                                                mosaic: () => State;

                                                                                                                                                                                                                                                                                                                                                                  method motionBlur

                                                                                                                                                                                                                                                                                                                                                                  motionBlur: (radius: number, sigma?: number, angle?: number) => State;

                                                                                                                                                                                                                                                                                                                                                                    method name

                                                                                                                                                                                                                                                                                                                                                                    name: () => State;

                                                                                                                                                                                                                                                                                                                                                                      method negative

                                                                                                                                                                                                                                                                                                                                                                      negative: () => State;

                                                                                                                                                                                                                                                                                                                                                                        method noise

                                                                                                                                                                                                                                                                                                                                                                        noise: (type: NoiseType | string | number) => State;

                                                                                                                                                                                                                                                                                                                                                                          method noop

                                                                                                                                                                                                                                                                                                                                                                          noop: () => State;

                                                                                                                                                                                                                                                                                                                                                                            method noProfile

                                                                                                                                                                                                                                                                                                                                                                            noProfile: () => State;

                                                                                                                                                                                                                                                                                                                                                                              method normalize

                                                                                                                                                                                                                                                                                                                                                                              normalize: () => State;

                                                                                                                                                                                                                                                                                                                                                                                method opaque

                                                                                                                                                                                                                                                                                                                                                                                opaque: (color: string) => State;

                                                                                                                                                                                                                                                                                                                                                                                  method operator

                                                                                                                                                                                                                                                                                                                                                                                  operator: (
                                                                                                                                                                                                                                                                                                                                                                                  channel: string,
                                                                                                                                                                                                                                                                                                                                                                                  operator: ChannelOperator | string,
                                                                                                                                                                                                                                                                                                                                                                                  rvalue: number,
                                                                                                                                                                                                                                                                                                                                                                                  percent?: boolean
                                                                                                                                                                                                                                                                                                                                                                                  ) => State;

                                                                                                                                                                                                                                                                                                                                                                                    method orderedDither

                                                                                                                                                                                                                                                                                                                                                                                    orderedDither: (channelType: ChannelType | string, NxN: string) => State;

                                                                                                                                                                                                                                                                                                                                                                                      method orientation

                                                                                                                                                                                                                                                                                                                                                                                      orientation: {
                                                                                                                                                                                                                                                                                                                                                                                      (callback: GetterCallback<string>): State;
                                                                                                                                                                                                                                                                                                                                                                                      (opts: GetterOptions, callback: GetterCallback<string>): State;
                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                        method out

                                                                                                                                                                                                                                                                                                                                                                                        out: (...customArguments: string[]) => State;

                                                                                                                                                                                                                                                                                                                                                                                          method outputDirectory

                                                                                                                                                                                                                                                                                                                                                                                          outputDirectory: (directory: string) => State;

                                                                                                                                                                                                                                                                                                                                                                                            method page

                                                                                                                                                                                                                                                                                                                                                                                            page: (
                                                                                                                                                                                                                                                                                                                                                                                            width: number,
                                                                                                                                                                                                                                                                                                                                                                                            height: number,
                                                                                                                                                                                                                                                                                                                                                                                            arg?: '%' | '!' | '<' | '>' | string
                                                                                                                                                                                                                                                                                                                                                                                            ) => State;

                                                                                                                                                                                                                                                                                                                                                                                              method paint

                                                                                                                                                                                                                                                                                                                                                                                              paint: (radius: number) => State;

                                                                                                                                                                                                                                                                                                                                                                                                method pause

                                                                                                                                                                                                                                                                                                                                                                                                pause: (seconds: number) => State;

                                                                                                                                                                                                                                                                                                                                                                                                  method pen

                                                                                                                                                                                                                                                                                                                                                                                                  pen: (color: string) => State;

                                                                                                                                                                                                                                                                                                                                                                                                    method ping

                                                                                                                                                                                                                                                                                                                                                                                                    ping: () => State;

                                                                                                                                                                                                                                                                                                                                                                                                      method pointSize

                                                                                                                                                                                                                                                                                                                                                                                                      pointSize: (size: number) => State;

                                                                                                                                                                                                                                                                                                                                                                                                        method preview

                                                                                                                                                                                                                                                                                                                                                                                                        preview: (type: PreviewType | string) => State;

                                                                                                                                                                                                                                                                                                                                                                                                          method process

                                                                                                                                                                                                                                                                                                                                                                                                          process: (command: string) => State;

                                                                                                                                                                                                                                                                                                                                                                                                            method profile

                                                                                                                                                                                                                                                                                                                                                                                                            profile: (filename: string) => State;

                                                                                                                                                                                                                                                                                                                                                                                                              method progress

                                                                                                                                                                                                                                                                                                                                                                                                              progress: () => State;

                                                                                                                                                                                                                                                                                                                                                                                                                method quality

                                                                                                                                                                                                                                                                                                                                                                                                                quality: (level: number) => State;

                                                                                                                                                                                                                                                                                                                                                                                                                  method raise

                                                                                                                                                                                                                                                                                                                                                                                                                  raise: (width: number, height: number) => State;

                                                                                                                                                                                                                                                                                                                                                                                                                    method randomThreshold

                                                                                                                                                                                                                                                                                                                                                                                                                    randomThreshold: (channelType: ChannelType, LOWxHIGH: string) => State;

                                                                                                                                                                                                                                                                                                                                                                                                                      method rawSize

                                                                                                                                                                                                                                                                                                                                                                                                                      rawSize: (width: number, height: number, offset?: number) => State;

                                                                                                                                                                                                                                                                                                                                                                                                                        method recolor

                                                                                                                                                                                                                                                                                                                                                                                                                        recolor: (matrix: string) => State;

                                                                                                                                                                                                                                                                                                                                                                                                                          method redPrimary

                                                                                                                                                                                                                                                                                                                                                                                                                          redPrimary: (x: number, y: number) => State;

                                                                                                                                                                                                                                                                                                                                                                                                                            method region

                                                                                                                                                                                                                                                                                                                                                                                                                            region: (width: number, height: number, x?: number, y?: number) => State;

                                                                                                                                                                                                                                                                                                                                                                                                                              method remote

                                                                                                                                                                                                                                                                                                                                                                                                                              remote: () => State;

                                                                                                                                                                                                                                                                                                                                                                                                                                method render

                                                                                                                                                                                                                                                                                                                                                                                                                                render: () => State;

                                                                                                                                                                                                                                                                                                                                                                                                                                  method repage

                                                                                                                                                                                                                                                                                                                                                                                                                                  repage: {
                                                                                                                                                                                                                                                                                                                                                                                                                                  (reset: '+' | string): State;
                                                                                                                                                                                                                                                                                                                                                                                                                                  (
                                                                                                                                                                                                                                                                                                                                                                                                                                  width: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                  height: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                  xoff: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                  yoff: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                  arg?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                  ): State;
                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                    method res

                                                                                                                                                                                                                                                                                                                                                                                                                                    res: {
                                                                                                                                                                                                                                                                                                                                                                                                                                    (callback: GetterCallback<string>): State;
                                                                                                                                                                                                                                                                                                                                                                                                                                    (opts: GetterOptions, callback: GetterCallback<string>): State;
                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                      method resample

                                                                                                                                                                                                                                                                                                                                                                                                                                      resample: (horizontal: number, vertical: number) => State;

                                                                                                                                                                                                                                                                                                                                                                                                                                        method resize

                                                                                                                                                                                                                                                                                                                                                                                                                                        resize: {
                                                                                                                                                                                                                                                                                                                                                                                                                                        (width: number, height: number, option: ResizeOption): State;
                                                                                                                                                                                                                                                                                                                                                                                                                                        (width: number, height?: number, option?: ResizeOption): State;
                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                          method roll

                                                                                                                                                                                                                                                                                                                                                                                                                                          roll: (horizontal: number, vertical: number) => State;

                                                                                                                                                                                                                                                                                                                                                                                                                                            method rotate

                                                                                                                                                                                                                                                                                                                                                                                                                                            rotate: (backgroundColor: string, degrees: number) => State;

                                                                                                                                                                                                                                                                                                                                                                                                                                              method sample

                                                                                                                                                                                                                                                                                                                                                                                                                                              sample: (geometry: string) => State;

                                                                                                                                                                                                                                                                                                                                                                                                                                                method samplingFactor

                                                                                                                                                                                                                                                                                                                                                                                                                                                samplingFactor: (horizontalFactor: number, verticalFactor: number) => State;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  method scale

                                                                                                                                                                                                                                                                                                                                                                                                                                                  scale: (width: number, height: number) => State;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    method scene

                                                                                                                                                                                                                                                                                                                                                                                                                                                    scene: (index: number) => State;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      method scenes

                                                                                                                                                                                                                                                                                                                                                                                                                                                      scenes: (start: number, end: number) => State;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        method screen

                                                                                                                                                                                                                                                                                                                                                                                                                                                        screen: () => State;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          method segment

                                                                                                                                                                                                                                                                                                                                                                                                                                                          segment: (clustherThreshold: number, smoothingThreshold: number) => State;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            method selectFrame

                                                                                                                                                                                                                                                                                                                                                                                                                                                            selectFrame: (frame: number) => State;
                                                                                                                                                                                                                                                                                                                                                                                                                                                            • change the specified frame.

                                                                                                                                                                                                                                                                                                                                                                                                                                                            method sepia

                                                                                                                                                                                                                                                                                                                                                                                                                                                            sepia: () => State;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              method set

                                                                                                                                                                                                                                                                                                                                                                                                                                                              set: (attribute: string, value: string) => State;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method setDraw

                                                                                                                                                                                                                                                                                                                                                                                                                                                                setDraw: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                property: SetDrawProperty | string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                x: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                y: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                method: SetDrawMethod | string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => State;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method setFormat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  setFormat: (format: string) => State;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method shade

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    shade: (azimuth: number, elevation: number) => State;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method shadow

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      shadow: (radius: number, sigma?: number) => State;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method sharedMemory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        sharedMemory: () => State;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method sharpen

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          sharpen: (radius: number, sigma?: number) => State;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method shave

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            shave: (width: number, height: number, percent?: boolean) => State;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method shear

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              shear: (xDegrees: number, yDegress: number) => State;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method silent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                silent: () => State;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method size

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  size: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (callback: GetterCallback<Dimensions>): State;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (opts: GetterOptions, callback: GetterCallback<Dimensions>): State;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method snaps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    snaps: (count: number) => State;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method solarize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      solarize: (threshold: number) => State;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method spread

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        spread: (amount: number) => State;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method stegano

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          stegano: (offset: number) => State;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method stereo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            stereo: () => State;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method stream

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              stream: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (callback?: WriteCallback): stream.PassThrough;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (format: string, callback?: WriteCallback): stream.PassThrough;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method strip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                strip: () => State;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method stroke

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  stroke: (color: string, width?: number) => State;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method strokeWidth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    strokeWidth: (width: number) => State;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method swirl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      swirl: (degrees: number) => State;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method textFont

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        textFont: (font: string) => State;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method threshold

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          threshold: (value: number, percent?: boolean) => State;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method thumb

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            thumb: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            width: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            height: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            outName: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            callback: WriteCallback
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ): State;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            width: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            height: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            outName: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            quality: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            callback: WriteCallback
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ): State;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            width: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            height: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            outName: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            quality: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            align: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            callback: WriteCallback
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ): State;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method tile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              tile: (filename: string) => State;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method title

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                title: (title: string) => State;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method toBuffer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  toBuffer: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (callback: (err: Error | null, buffer: Buffer) => any): stream.PassThrough;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  format: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  callback: (err: Error, buffer: Buffer) => any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ): stream.PassThrough;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method transform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    transform: (color: string) => State;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method transparent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      transparent: (color: string) => State;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method treeDepth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        treeDepth: (depth: number) => State;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method trim

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          trim: () => State;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type: (type: ImageType | string) => State;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method units

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              units: (type: UnitType | string) => State;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method unsharp

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                unsharp: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                radius: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                sigma?: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                amount?: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                threshold?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => State;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method update

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  update: (seconds: number) => State;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method usePixmap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    usePixmap: () => State;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method view

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      view: () => State;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method virtualPixel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        virtualPixel: (method: VirtualPixelMethod | string) => State;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method visual

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          visual: (type: VisualType | string) => State;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method watermark

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            watermark: (brightness: number, saturation: number) => State;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method wave

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              wave: (amplitude: number, wavelength: number) => State;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method whitePoint

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                whitePoint: (x: number, y: number) => State;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method whiteThreshold

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  whiteThreshold: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (intensity: number): State;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (red: number, green: number, blue: number, opacity?: number): State;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method window

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    window: (id: string) => State;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method windowGroup

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      windowGroup: () => State;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method write

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        write: (filename: string, callback: WriteCallback) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface SubClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface SubClass {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (image: string): State;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (stream: NodeJS.ReadableStream | Buffer, image?: string): State;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (width: number, height: number, color?: string): State;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Type Aliases

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ChannelOperator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ChannelOperator =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'Add'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'And'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'Assign'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'Depth'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'Divide'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'Gamma'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'Negate'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'LShift'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'Log'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'Max'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'Min'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'Multiply'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'Or'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'Pow'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'RShift'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'Subtract'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'Threshold'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'Threshold-White'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'Threshold-White-Negate'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'Threshold-Black'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'Threshold-Black-Negate'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'Xor'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'Noise-Gaussian'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'Noise-Impulse'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'Noise-Laplacian'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'Noise-Multiplicative'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'Noise-Poisson'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'Noise-Random'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'Noise-Uniform';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ChannelType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ChannelType =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'All'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'Intensity'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'Red'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'Green'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'Blue'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'Cyan'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'Magenta'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'Yellow'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'Black'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'Opacity';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ColorSpace

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ColorSpace =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'CineonLog'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'CMYK'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'GRAY'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'HSL'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'HSB'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'OHTA'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'RGB'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'Rec601Luma'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'Rec709Luma'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'Rec601YCbCr'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'Rec709YCbCr'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'Transparent'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'XYZ'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'YCbCr'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'YIQ'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'YPbPr'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'YUV';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type CompareCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type CompareCallback = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        err: Error | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isEqual: boolean,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        equality: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        raw: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type ComposeOperator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type ComposeOperator =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'Over'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'In'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'Out'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'Atop'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'Xor'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'Plus'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'Minus'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'Add'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'Subtract'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'Difference'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'Divide'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'Multiply'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'Bumpmap'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'Copy'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'CopyRed'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'CopyGreen'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'CopyBlue'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'CopyOpacity'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'CopyCyan'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'CopyMagenta'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'CopyYellow'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'CopyBlack';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type CompressionType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type CompressionType =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'None'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'BZip'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'Fax'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'Group4'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'JPEG'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'Lossless'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'LZW'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'RLE'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'Zip'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'LZMA';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type DisposeMethod

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type DisposeMethod = 'Undefined' | 'None' | 'Background' | 'Previous';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type Encoding

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type Encoding =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'AdobeCustom'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'AdobeExpert'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'AdobeStandard'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'AppleRoman'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'BIG5'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'GB2312'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'Latin 2'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'None'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'SJIScode'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'Symbol'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'Unicode'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 'Wansung';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type EndianType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type EndianType = 'MSB' | 'LSB' | 'Native';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type FilterType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type FilterType =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'Point'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'Box'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'Triangle'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'Hermite'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'Hanning'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'Hamming'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'Blackman'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'Gaussian'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'Quadratic'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'Cubic'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'Catrom'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'Mitchell'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'Lanczos'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'Bessel'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'Sinc';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type GetterCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type GetterCallback<T> = (err: Error | null, value: T) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type GravityDirection

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type GravityDirection =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'NorthWest'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'North'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'NorthEast'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'West'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'Center'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'East'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'SouthWest'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'South'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'SouthEast';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type HighlightStyle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type HighlightStyle = 'Assign' | 'Threshold' | 'Tint' | 'XOR';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type ImageType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type ImageType =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'Bilevel'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'Grayscale'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'Palette'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'PaletteMatte'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'TrueColor'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'TrueColorMatte'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'ColorSeparation'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'ColorSeparationMatte'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'Optimize';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type IntentType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type IntentType = 'Absolute' | 'Perceptual' | 'Relative' | 'Saturation';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type InterlaceType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type InterlaceType = 'None' | 'Line' | 'Plane' | 'Partition';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type LimitType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type LimitType = 'disk' | 'file' | 'map' | 'memory' | 'pixels' | 'threads';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ListType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ListType =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'Color'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'Delegate'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'Format'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'Magic'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'Module'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'Resource'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'Type';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type NamedColor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type NamedColor =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'Red'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'Green'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'Blue'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'Opacity'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'Matte'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'Cyan'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'Magenta'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'Yellow'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'Black'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'Gray';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type NoiseType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type NoiseType =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'uniform'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'gaussian'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'multiplicative'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'impulse'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'laplacian'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'poisson';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type OperationMode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type OperationMode = 'frame' | 'unframe' | 'concatenate';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type PreviewType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type PreviewType =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'Rotate'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'Shear'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'Roll'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'Hue'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'Saturation'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'Brightness'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'Gamma'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'Spiff'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'Dull'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'Grayscale'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'Quantize'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'Despeckle'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'ReduceNoise'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'AddNoise'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'Sharpen'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'Blur'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'Threshold'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'EdgeDetect'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'Spread'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'Shade'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'Raise'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'Segment'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'Solarize'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'Swirl'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'Implode'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'Wave'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'OilPaint'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'CharcoalDrawing'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'JPEG';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ResizeOption

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ResizeOption =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | '%' /** Width and height are specified in percents */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | '@' /** Specify maximum area in pixels */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | '!' /** Ignore aspect ratio */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | '^' /** Width and height are minimum values */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | '<' /** Change dimensions only if image is smaller than width or height */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | '>';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type SetDrawMethod

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type SetDrawMethod = 'point' | 'replace' | 'floodfill' | 'filltoborder' | 'reset';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type SetDrawProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type SetDrawProperty = 'color' | 'matte';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type UnitType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type UnitType = 'Undefined' | 'PixelsPerInch' | 'PixelsPerCentimeter';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type VirtualPixelMethod

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type VirtualPixelMethod = 'Constant' | 'Edge' | 'Mirror' | 'Tile';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type VisualType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type VisualType =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'StaticGray'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'GrayScale'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'StaticColor'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'PseudoColor'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'TrueColor'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'DirectColor'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 'default';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type WriteCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type WriteCallback = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          err: Error | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          stdout: stream.Readable,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          stderr: stream.Readable,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          cmd: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Package Files (1)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Dependencies (1)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Dev Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            No dev dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            No peer dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Badge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/gm.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@types/gm)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • HTML
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              <a href="https://www.jsdocs.io/package/@types/gm"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>