@types/gm

  • Version 1.25.0
  • Published
  • 24.5 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?: string | 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: {
                                                                                                                                        (ltr?: boolean): State;
                                                                                                                                        (image: string | string[], ltr?: boolean): State;
                                                                                                                                        };

                                                                                                                                          method authenticate

                                                                                                                                          authenticate: (password: string) => State;

                                                                                                                                            method autoOrient

                                                                                                                                            autoOrient: () => State;

                                                                                                                                              method average

                                                                                                                                              average: () => 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 texture

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            texture: (filename: 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 thumbnail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  thumbnail: (width: number, height: number, options?: ResizeOption) => 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>