@types/gm

Version 1.25.4
Published 5 months ago
24.6 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

compare()
m()
subClass()

Interfaces

ChannelInfo
ClassOptions
ColorStatistics
CompareOptions
Dimensions
- height
- width
GetterOptions
- bufferStream
ImageInfo
State
SubClass

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: (centiseconds: 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)

index.d.ts

Dependencies (1)

@types/node

Dev Dependencies (0)

No dev dependencies.

Peer Dependencies (0)

No peer dependencies.

Badge

To add a badge like this oneto 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>

Updated 5 months ago.
Package analyzed in 7097 ms.
Missing or incorrect documentation? Open an issue for this package.