diff --git a/gm/gm-tests.ts b/gm/gm-tests.ts
new file mode 100644
index 0000000000..e3172dfc6a
--- /dev/null
+++ b/gm/gm-tests.ts
@@ -0,0 +1,350 @@
+/// <reference path="gm.d.ts" />
+/// <reference path="../node/node.d.ts" />
+
+import gm = require('gm');
+import stream = require('stream');
+
+var src: string;
+var matrix: string;
+var enable: boolean;
+var ltr: boolean;
+var password: string;
+var bits: number;
+var intensity: number;
+var r: number;
+var g: number;
+var b: number;
+var opacity: number;
+var x: number;
+var y: number;
+var radius: number;
+var sigma: number;
+var width: number;
+var height: number;
+var color: string;
+var channel: string;
+var type: string;
+var factor: number;
+var numColors: number;
+var operator: string;
+var multiplier: number;
+var kernel: string;
+var usePercent: boolean;
+var time: number;
+var server: string;
+var method: string;
+var percent: number;
+var encoding: string;
+var options: string;
+var file: string;
+var distance: number;
+var geometry: string;
+var direction: string;
+var name: string;
+var offset: number;
+var blackPoint: number;
+var gamma: number;
+var whitePoint: number;
+var limit: string;
+var format: string;
+var iterations: number;
+var count: number;
+var b: number;
+var s: number;
+var h: number;
+var dest: string;
+var images: string[];
+var angle: number;
+var NxN: string;
+var size: number;
+var command: string;
+var index: number;
+var threshold: number;
+var attribute: string;
+var attrValue: string;
+var format: string;
+var font: string;
+var quality: number;
+var align: string;
+var depth: number;
+var readStream: stream.PassThrough;
+
+gm(src)
+	.adjoin()
+	.affine(matrix)
+	.antialias(enable)
+	.append(src)
+	.append(src, ltr)
+	.authenticate(password)
+	.autoOrient()
+	.backdrop()
+	.bitdepth(bits)
+	.blackThreshold(intensity)
+	.blackThreshold(r, g, b)
+	.blackThreshold(r, g, b, opacity)
+	.bluePrimary(x, y)
+	.blur(radius)
+	.blur(radius, sigma)
+	.border(width, height)
+	.borderColor(color)
+	.box(color)
+	.channel(channel)
+	.charcoal(factor)
+	.chop(width, height)
+	.chop(width, height, x, y)
+	.clip()
+	.coalesce()
+	.colorize(r, g, b)
+	.colorMap(type)
+	.colors(numColors)
+	.colorspace(type)
+	.compose(operator)
+	.compress(type)
+	.contrast(multiplier)
+	.convolve(kernel)
+	.createDirectories()
+	.crop(width, height)
+	.crop(width, height, x, y)
+	.crop(width, height, x, y, usePercent)
+	.cycle(factor)
+	.deconstruct()
+	.define()
+	.delay(time)
+	.density(width, height)
+	.despeckle()
+	.displace(x, y)
+	.display(server)
+	.dispose(method)
+	.dissolve(percent)
+	.dither()
+	.dither(enable)
+	.edge()
+	.edge(radius)
+	.emboss()
+	.emboss(radius)
+	.encoding(encoding)
+	.endian(type)
+	.enhance()
+	.equalize()
+	.extent(width, height)
+	.extent(width, height, options)
+	.file(file)
+	.filter(type)
+	.flatten()
+	.flip()
+	.flop()
+	.foreground(color)
+	.frame(width, height, width, height)
+	.fuzz(distance)
+	.fuzz(distance, usePercent)
+	.gamma(r, b, g)
+	.gaussian(radius)
+	.gaussian(radius, sigma)
+	.geometry(width, height)
+	.geometry(width, height, options)
+	.geometry(geometry)
+	.greenPrimary(x, y)
+	.gravity(direction)
+	.highlightColor(color)
+	.highlightStyle(type)
+	.iconGeometry(geometry)
+	.implode()
+	.implode(factor)
+	.intent(type)
+	.interlace(type)
+	.label(name)
+	.lat(width, height, offset)
+	.lat(width, height, offset, usePercent)
+	.level(blackPoint, gamma, whitePoint)
+	.level(blackPoint, gamma, whitePoint, usePercent)
+	.limit(type, limit)
+	.list(type)
+	.log(format)
+	.loop(iterations)
+	.lower(width, height)
+	.magnify(factor)
+	.map(file)
+	.mask(file)
+	.matte()
+	.matteColor(color)
+	.maximumError(count)
+	.median()
+	.median(radius)
+	.minify(factor)
+	.mode(type)
+	.modulate(b, s, h)
+	.monitor()
+	.monochrome()
+	.morph(src, dest)
+	.morph(src, dest, (err, stdout, stderr, cmd) => {
+	})
+	.morph(images, dest)
+	.morph(images, dest, (err, stdout, stderr, cmd) => {
+	})
+	.mosaic()
+	.motionBlur(radius)
+	.motionBlur(radius, sigma)
+	.motionBlur(radius, sigma, angle)
+	.name()
+	.negative()
+	.noise(type)
+	.noise(radius)
+	.noop()
+	.normalize()
+	.opaque(color)
+	.operator(channel, operator, factor)
+	.operator(channel, operator, factor, usePercent)
+	.orderedDither(channel, NxN)
+	.outputDirectory(dest)
+	.page(width, height)
+	.page(width, height, options)
+	.pause(time)
+	.pen(color)
+	.ping()
+	.pointSize(size)
+	.noProfile()
+	.preview(type)
+	.paint(radius)
+	.process(command)
+	.profile(file)
+	.progress()
+	.randomThreshold(channel, NxN)
+	.quality(factor)
+	.raise(width, height)
+	.recolor(matrix)
+	.redPrimary(x, y)
+	.region(width, height)
+	.region(width, height, x, y)
+	.remote()
+	.render()
+	.repage('+')
+	.repage(width, height, x, y)
+	.repage(width, height, x, y, options)
+	.sample(geometry)
+	.samplingFactor(factor, factor)
+	.rawSize(width, height)
+	.rawSize(width, height, offset)
+	.resample(width, height)
+	.resize(width, height)
+	.resize(width, height, options)
+	.roll(x, y)
+	.rotate(color, angle)
+	.scene(index)
+	.scenes(index, index)
+	.scale(width, height)
+	.screen()
+	.segment(threshold, threshold)
+	.sepia()
+	.set(attribute, attrValue)
+	.setFormat(format)
+	.shade(angle, distance)
+	.shadow(radius)
+	.shadow(radius, sigma)
+	.sharedMemory()
+	.shave(width, height)
+	.shave(width, height, usePercent)
+	.sharpen(radius)
+	.sharpen(radius, sigma)
+	.shear(angle, angle)
+	.silent()
+	.snaps(count)
+	.solarize(threshold)
+	.spread(distance)
+	.stegano(offset)
+	.stereo()
+	.strip()
+	.swirl(angle)
+	.textFont(font)
+	.threshold(threshold)
+	.threshold(threshold, usePercent)
+	.thumb(width, height, dest, (err, stdout, stderr, cmd) => {
+	})
+	.thumb(width, height, dest, quality, (err, stdout, stderr, cmd) => {
+	})
+	.thumb(width, height, dest, quality, align, (err, stdout, stderr, cmd) => {
+	})
+	.tile(file)
+	.title(name)
+	.transform(color)
+	.transparent(color)
+	.treeDepth(depth)
+	.trim()
+	.type(type)
+	.update(time)
+	.units(type)
+	.unsharp(radius)
+	.unsharp(radius, sigma)
+	.unsharp(radius, sigma, factor)
+	.unsharp(radius, sigma, factor, threshold)
+	.usePixmap()
+	.view()
+	.virtualPixel(method)
+	.visual(type)
+	.watermark(b, s)
+	.wave(factor, distance)
+	.whitePoint(x, y)
+	.whiteThreshold(intensity)
+	.whiteThreshold(r, g, b)
+	.whiteThreshold(r, g, b, opacity)
+	.window(name)
+	.windowGroup()
+	.color((err, color) => {
+	})
+	.depth((err, bitdepth) => {
+	})
+	.filesize((err, size) => {
+	})
+	.format((err, format) => {
+	})
+	.identify((err, info) => {
+	})
+	.res((err, resolution) => {
+	})
+	.size((err, size) => {
+	})
+	.orientation((err, orient) => {
+	})
+	.draw(options)
+	.drawArc(x, y, x, y, radius, radius)
+	.drawBezier(x, y, x, y)
+	.drawBezier(x, y, x, y, x, y)
+	.drawBezier(x, y, x, y, x, y, x, y)
+	.drawCircle(x, y, x, y)
+	.drawEllipse(x, y, radius, radius, radius, radius)
+	.drawLine(x, y, x, y)
+	.drawPoint(x, y)
+	.drawPolygon(x, y, x, y, x, y)
+	.drawPolygon(x, y, x, y, x, y, x, y)
+	.drawPolyline(x, y, x, y, x, y)
+	.drawPolyline(x, y, x, y, x, y, x, y)
+	.drawRectangle(x, y, x, y)
+	.drawRectangle(x, y, x, y, radius)
+	.drawRectangle(x, y, x, y, radius, radius)
+	.drawText(x, y, name, direction)
+	.fill(color)
+	.font(font)
+	.font(font, size)
+	.fontSize(size)
+	.stroke(color)
+	.stroke(color, width)
+	.setDraw(type, x, y, method)
+	.write(dest, (err, stdout, stderr, cmd) => {
+	});
+
+gm.compare(file, file, (err, isEqual, equality, raw) => {
+});
+
+readStream = gm(src).stream();
+readStream = gm(src).stream(format);
+readStream = gm(src).stream(format, (err, stdout, stderr, cmd) => {
+});
+
+gm(src).toBuffer((err, buffer) => {
+});
+gm(src).toBuffer(format, (err, buffer) => {
+});
+
+var imageMagick = gm.subClass({ imageMagick: true });
+var readStream = imageMagick(src)
+	.adjoin()
+	.stream();
diff --git a/gm/gm.d.ts b/gm/gm.d.ts
new file mode 100644
index 0000000000..2373300fee
--- /dev/null
+++ b/gm/gm.d.ts
@@ -0,0 +1,623 @@
+// Type definitions for gm 1.17.0
+// Project: https://github.com/aheckmann/gm
+// Definitions by: Joel Spadin <https://github.com/ChaosinaCan>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../node/node.d.ts"/>
+
+declare module "gm" {
+	import stream = require('stream');
+
+	function m(image: string): m.State;
+
+	module m {
+		export interface ClassOptions {
+			imageMagick?: boolean;
+		}
+
+		export interface CompareCallback {
+			(err: Error, isEqual: boolean, equality: number, raw: number): any;
+		}
+
+		export interface GetterCallback<T> {
+			(err: Error, value: T): any;
+		}
+
+		export interface WriteCallback {
+			(err: Error, stdout: string, stderr: string, cmd: string): any;
+		}
+
+		export interface ChannelInfo<T> {
+			Red: T;
+			Green: T;
+			Blue: T;
+		}
+
+		export interface CompareOptions {
+			file?: string;
+			highlightColor?: string;
+			highlightStyle?: string;
+			tolerance?: number;
+		}
+
+		export interface ColorStatistics {
+			Minimum: string;
+			Maximum: string;
+			Mean: string;
+			'Standard Deviation': string;
+		}
+
+		export interface Dimensions {
+			width: number;
+			height: number;
+		}
+
+		export interface ImageInfo {
+			'Background Color': string;
+			'Border Color': string;
+			'Channel Depths': ChannelInfo<string>;
+			'Channel Statistics': ChannelInfo<ColorStatistics>;
+			Class: string;
+			color: number;
+			Compose: string;
+			Compression: string;
+			depth: number;
+			Depth: string;
+			Dispose: string;
+			Filesize: string;
+			format: string;
+			Format: string;
+			Geometry: string;
+			Interlace: string;
+			Iterations: string;
+			'JPEG-Quality'?: string;
+			'JPEG-Colorspace'?: string;
+			'JPEG-Colorspace-Name'?: string;
+			'JPEG-Sampling-factors'?: string;
+			'Matte Color': string;
+			Orientation: string;
+			'Page geometry': string;
+			path: string;
+
+			'Profile-color'?: string;
+			'Profile-iptc'?: {
+				[key: string]: string;
+			};
+			'Profile-EXIF'?: {
+				[key: string]: string;
+			};
+			'Profile-XMP'?: string;
+			Resolution?: string;
+			size: Dimensions;
+			Signature: string;
+			Software: string;
+			Tainted: string;
+			Type: string;
+		}
+
+		export interface State {
+			// Image Operations
+			adjoin(): State;
+			affine(matrix: string): State;
+			antialias(enable: boolean): State;
+			append(image: string, ltr?: boolean): State;
+			authenticate(password: string): State;
+			autoOrient(): State;
+			backdrop(): State;
+			bitdepth(bits: number): State;
+			blackThreshold(intensity: number): State;
+			blackThreshold(red: number, green: number, blue: number, opacity?: number): State;
+			bluePrimary(x: number, y: number): State;
+			blur(radius: number, sigma?: number): State;
+			border(width: number, height: number): State;
+			borderColor(color: string): State;
+			box(color: string): State;
+			channel(type: 'Red'): State;
+			channel(type: 'Green'): State;
+			channel(type: 'Blue'): State;
+			channel(type: 'Opacity'): State;
+			channel(type: 'Matte'): State;
+			channel(type: 'Cyan'): State;
+			channel(type: 'Magenta'): State;
+			channel(type: 'Yellow'): State;
+			channel(type: 'Black'): State;
+			channel(type: 'Gray'): State;
+			channel(type: string): State;
+			charcoal(factor: number): State;
+			chop(width: number, height: number, x?: number, y?: number): State;
+			clip(): State;
+			coalesce(): State;
+			colorize(red: number, green: number, blue: number): State;
+			colorMap(type: 'shared'): State;
+			colorMap(type: 'private'): State;
+			colorMap(type: string): State;
+			colors(colors: number): State;
+			colorspace(space: 'CineonLog'): State;
+			colorspace(space: 'CMYK'): State;
+			colorspace(space: 'GRAY'): State;
+			colorspace(space: 'HSL'): State;
+			colorspace(space: 'HSB'): State;
+			colorspace(space: 'OHTA'): State;
+			colorspace(space: 'RGB'): State;
+			colorspace(space: 'Rec601Luma'): State;
+			colorspace(space: 'Rec709Luma'): State;
+			colorspace(space: 'Rec601YCbCr'): State;
+			colorspace(space: 'Rec709YCbCr'): State;
+			colorspace(space: 'Transparent'): State;
+			colorspace(space: 'XYZ'): State;
+			colorspace(space: 'YCbCr'): State;
+			colorspace(space: 'YIQ'): State;
+			colorspace(space: 'YPbPr'): State;
+			colorspace(space: 'YUV'): State;
+			colorspace(space: string): State;
+			compose(operator: 'Over'): State;
+			compose(operator: 'In'): State;
+			compose(operator: 'Out'): State;
+			compose(operator: 'Atop'): State;
+			compose(operator: 'Xor'): State;
+			compose(operator: 'Plus'): State;
+			compose(operator: 'Minus'): State;
+			compose(operator: 'Add'): State;
+			compose(operator: 'Subtract'): State;
+			compose(operator: 'Difference'): State;
+			compose(operator: 'Divide'): State;
+			compose(operator: 'Multiply'): State;
+			compose(operator: 'Bumpmap'): State;
+			compose(operator: 'Copy'): State;
+			compose(operator: 'CopyRed'): State;
+			compose(operator: 'CopyGreen'): State;
+			compose(operator: 'CopyBlue'): State;
+			compose(operator: 'CopyOpacity'): State;
+			compose(operator: 'CopyCyan'): State;
+			compose(operator: 'CopyMagenta'): State;
+			compose(operator: 'CopyYellow'): State;
+			compose(operator: 'CopyBlack'): State;
+			compose(operator: string): State;
+			compress(type: 'None'): State;
+			compress(type: 'BZip'): State;
+			compress(type: 'Fax'): State;
+			compress(type: 'Group4'): State;
+			compress(type: 'JPEG'): State;
+			compress(type: 'Lossless'): State;
+			compress(type: 'LZW'): State;
+			compress(type: 'RLE'): State;
+			compress(type: 'Zip'): State;
+			compress(type: 'LZMA'): State;
+			compress(type: string): State;
+			contrast(multiplier: number): State;
+			convolve(kernel: string): State;
+			createDirectories(): State;
+			crop(width: number, height: number, x?: number, y?: number, percent?: boolean): State;
+			cycle(amount: number): State;
+			deconstruct(): State;
+			define(): State;
+			delay(milliseconds: number): State;
+			density(width: number, height: number): State;
+			despeckle(): State;
+			displace(horizontal: number, vertical: number): State;
+			display(xServer: string): State;
+			dispose(method: 'Undefined'): State;
+			dispose(method: 'None'): State;
+			dispose(method: 'Background'): State;
+			dispose(method: 'Previous'): State;
+			dispose(method: string): State;
+			dissolve(percent: number): State;
+			dither(enable?: boolean): State;
+			edge(radius?: number): State;
+			emboss(radius?: number): State;
+			encoding(encoding: 'AdobeCustom'): State;
+			encoding(encoding: 'AdobeExpert'): State;
+			encoding(encoding: 'AdobeStandard'): State;
+			encoding(encoding: 'AppleRoman'): State;
+			encoding(encoding: 'BIG5'): State;
+			encoding(encoding: 'GB2312'): State;
+			encoding(encoding: 'Latin 2'): State;
+			encoding(encoding: 'None'): State;
+			encoding(encoding: 'SJIScode'): State;
+			encoding(encoding: 'Symbol'): State;
+			encoding(encoding: 'Unicode'): State;
+			encoding(encoding: 'Wansung'): State;
+			encoding(encoding: string): State;
+			endian(type: 'MSB'): State;
+			endian(type: 'LSB'): State;
+			endian(type: 'Native'): State;
+			endian(type: string): State;
+			enhance(): State;
+			equalize(): State;
+			extent(width: number, height: number, options?: string): State;
+			file(filename: string): State;
+			filter(type: 'Point'): State;
+			filter(type: 'Box'): State;
+			filter(type: 'Triangle'): State;
+			filter(type: 'Hermite'): State;
+			filter(type: 'Hanning'): State;
+			filter(type: 'Hamming'): State;
+			filter(type: 'Blackman'): State;
+			filter(type: 'Gaussian'): State;
+			filter(type: 'Quadratic'): State;
+			filter(type: 'Cubic'): State;
+			filter(type: 'Catrom'): State;
+			filter(type: 'Mitchell'): State;
+			filter(type: 'Lanczos'): State;
+			filter(type: 'Bessel'): State;
+			filter(type: 'Sinc'): State;
+			filter(type: string): State;
+			flatten(): State;
+			flip(): State;
+			flop(): State;
+			foreground(color: string): State;
+			frame(width: number, height: number, outerBevelWidth: number, outBevelHeight: number): State;
+			fuzz(distance: number, percent?: boolean): State;
+			gamma(r: number, g: number, b: number): State;
+			gaussian(radius: number, sigma?: number): State;
+			/** Width and height are specified in percents */
+			geometry(width: number, height: number, option: '%'): State;
+			/** Specify maximum area in pixels */
+			geometry(width: number, height: number, option: '@'): State;
+			/** Ignore aspect ratio */
+			geometry(width: number, height: number, option: '!'): State;
+			/** Width and height are minimum values */
+			geometry(width: number, height: number, option: '^'): State;
+			/** Change dimensions only if image is smaller than width or height */
+			geometry(width: number, height: number, option: '<'): State;
+			/** Change dimensions only if image is larger than width or height */
+			geometry(width: number, height: number, option: '>'): State;
+			geometry(width: number, height?: number, option?: string): State;
+			geometry(geometry: string): State;
+			greenPrimary(x: number, y: number): State;
+			gravity(direction: 'NorthWest'): State;
+			gravity(direction: 'North'): State;
+			gravity(direction: 'NorthEast'): State;
+			gravity(direction: 'West'): State;
+			gravity(direction: 'Center'): State;
+			gravity(direction: 'East'): State;
+			gravity(direction: 'SouthWest'): State;
+			gravity(direction: 'South'): State;
+			gravity(direction: 'SouthEast'): State;
+			gravity(direction: string): State;
+			highlightColor(color: string): State;
+			highlightStyle(style: 'Assign'): State;
+			highlightStyle(style: 'Threshold'): State;
+			highlightStyle(style: 'Tint'): State;
+			highlightStyle(style: 'XOR'): State;
+			highlightStyle(style: string): State;
+			iconGeometry(geometry: string): State;
+			implode(factor?: number): State;
+			intent(type: 'Absolute'): State;
+			intent(type: 'Perceptual'): State;
+			intent(type: 'Relative'): State;
+			intent(type: 'Saturation'): State;
+			intent(type: string): State;
+			interlace(type: 'None'): State;
+			interlace(type: 'Line'): State;
+			interlace(type: 'Plane'): State;
+			interlace(type: 'Partition'): State;
+			interlace(type: string): State;
+			label(name: string): State;
+			lat(width: number, height: number, offset: number, percent?: boolean): State;
+			level(blackPoint: number, gamma: number, whitePoint: number, percent?: boolean): State;
+			limit(type: 'disk', val: string): State;
+			limit(type: 'file', val: string): State;
+			limit(type: 'map', val: string): State;
+			limit(type: 'memory', val: string): State;
+			limit(type: 'pixels', val: string): State;
+			limit(type: 'threads', val: string): State;
+			limit(type: string, val: string): State;
+			list(type: string): State;
+			list(type: 'Color'): State;
+			list(type: 'Delegate'): State;
+			list(type: 'Format'): State;
+			list(type: 'Magic'): State;
+			list(type: 'Module'): State;
+			list(type: 'Resource'): State;
+			list(type: 'Type'): State;
+			log(format: string): State;
+			loop(iterations: number): State;
+			lower(width: number, height: number): State;
+			magnify(factor: number): State;
+			map(filename: string): State;
+			mask(filename: string): State;
+			matte(): State;
+			matteColor(color: string): State;
+			maximumError(limit: number): State;
+			median(radius?: number): State;
+			minify(factor: number): State;
+			mode(mode: 'frame'): State;
+			mode(mode: 'unframe'): State;
+			mode(mode: 'concatenate'): State;
+			mode(mode: string): State;
+			modulate(b: number, s: number, h: number): State;
+			monitor(): State;
+			monochrome(): State;
+			morph(otherImg: string, outName: string, callback?: WriteCallback): State;
+			morph(otherImg: string[], outName: string, callback?: WriteCallback): State;
+			mosaic(): State;
+			motionBlur(radius: number, sigma?: number, angle?: number): State;
+			name(): State;
+			negative(): State;
+			noise(type: 'uniform'): State;
+			noise(type: 'gaussian'): State;
+			noise(type: 'multiplicative'): State;
+			noise(type: 'impulse'): State;
+			noise(type: 'laplacian'): State;
+			noise(type: 'poisson'): State;
+			noise(type: string): State;
+			noise(radius: number): State;
+			noop(): State;
+			normalize(): State;
+			opaque(color: string): State;
+			operator(channel: string, operator: 'Add', rvalue: number, percent?: boolean): State;
+			operator(channel: string, operator: 'And', rvalue: number, percent?: boolean): State;
+			operator(channel: string, operator: 'Assign', rvalue: number, percent?: boolean): State;
+			operator(channel: string, operator: 'Depth', rvalue: number, percent?: boolean): State;
+			operator(channel: string, operator: 'Divide', rvalue: number, percent?: boolean): State;
+			operator(channel: string, operator: 'Gamma', rvalue: number, percent?: boolean): State;
+			operator(channel: string, operator: 'Negate', rvalue: number, percent?: boolean): State;
+			operator(channel: string, operator: 'LShift', rvalue: number, percent?: boolean): State;
+			operator(channel: string, operator: 'Log', rvalue: number, percent?: boolean): State;
+			operator(channel: string, operator: 'Max', rvalue: number, percent?: boolean): State;
+			operator(channel: string, operator: 'Min', rvalue: number, percent?: boolean): State;
+			operator(channel: string, operator: 'Multiply', rvalue: number, percent?: boolean): State;
+			operator(channel: string, operator: 'Or', rvalue: number, percent?: boolean): State;
+			operator(channel: string, operator: 'Pow', rvalue: number, percent?: boolean): State;
+			operator(channel: string, operator: 'RShift', rvalue: number, percent?: boolean): State;
+			operator(channel: string, operator: 'Subtract', rvalue: number, percent?: boolean): State;
+			operator(channel: string, operator: 'Threshold', rvalue: number, percent?: boolean): State;
+			operator(channel: string, operator: 'Threshold-White', rvalue: number, percent?: boolean): State;
+			operator(channel: string, operator: 'Threshold-White-Negate', rvalue: number, percent?: boolean): State;
+			operator(channel: string, operator: 'Threshold-Black', rvalue: number, percent?: boolean): State;
+			operator(channel: string, operator: 'Threshold-Black-Negate', rvalue: number, percent?: boolean): State;
+			operator(channel: string, operator: 'Xor', rvalue: number, percent?: boolean): State;
+			operator(channel: string, operator: 'Noise-Gaussian', rvalue: number, percent?: boolean): State;
+			operator(channel: string, operator: 'Noise-Impulse', rvalue: number, percent?: boolean): State;
+			operator(channel: string, operator: 'Noise-Laplacian', rvalue: number, percent?: boolean): State;
+			operator(channel: string, operator: 'Noise-Multiplicative', rvalue: number, percent?: boolean): State;
+			operator(channel: string, operator: 'Noise-Poisson', rvalue: number, percent?: boolean): State;
+			operator(channel: string, operator: 'Noise-Random', rvalue: number, percent?: boolean): State;
+			operator(channel: string, operator: 'Noise-Uniform', rvalue: number, percent?: boolean): State;
+			operator(channel: string, operator: string, rvalue: number, percent?: boolean): State;
+			orderedDither(channelType: 'All', NxN: string): State;
+			orderedDither(channelType: 'Intensity', NxN: string): State;
+			orderedDither(channelType: 'Red', NxN: string): State;
+			orderedDither(channelType: 'Green', NxN: string): State;
+			orderedDither(channelType: 'Blue', NxN: string): State;
+			orderedDither(channelType: 'Cyan', NxN: string): State;
+			orderedDither(channelType: 'Magenta', NxN: string): State;
+			orderedDither(channelType: 'Yellow', NxN: string): State;
+			orderedDither(channelType: 'Black', NxN: string): State;
+			orderedDither(channelType: 'Opacity', NxN: string): State;
+			orderedDither(channelType: string, NxN: string): State;
+			outputDirectory(directory: string): State;
+			page(width: number, height: number, arg?: '%'): State;
+			page(width: number, height: number, arg?: '!'): State;
+			page(width: number, height: number, arg?: '<'): State;
+			page(width: number, height: number, arg?: '>'): State;
+			page(width: number, height: number, arg?: string): State;
+			pause(seconds: number): State;
+			pen(color: string): State;
+			ping(): State;
+			pointSize(size: number): State;
+			noProfile(): State;
+			preview(type: 'Rotate'): State;
+			preview(type: 'Shear'): State;
+			preview(type: 'Roll'): State;
+			preview(type: 'Hue'): State;
+			preview(type: 'Saturation'): State;
+			preview(type: 'Brightness'): State;
+			preview(type: 'Gamma'): State;
+			preview(type: 'Spiff'): State;
+			preview(type: 'Dull'): State;
+			preview(type: 'Grayscale'): State;
+			preview(type: 'Quantize'): State;
+			preview(type: 'Despeckle'): State;
+			preview(type: 'ReduceNoise'): State;
+			preview(type: 'AddNoise'): State;
+			preview(type: 'Sharpen'): State;
+			preview(type: 'Blur'): State;
+			preview(type: 'Threshold'): State;
+			preview(type: 'EdgeDetect'): State;
+			preview(type: 'Spread'): State;
+			preview(type: 'Shade'): State;
+			preview(type: 'Raise'): State;
+			preview(type: 'Segment'): State;
+			preview(type: 'Solarize'): State;
+			preview(type: 'Swirl'): State;
+			preview(type: 'Implode'): State;
+			preview(type: 'Wave'): State;
+			preview(type: 'OilPaint'): State;
+			preview(type: 'CharcoalDrawing'): State;
+			preview(type: 'JPEG'): State;
+			preview(type: string): State;
+			paint(radius: number): State;
+			process(command: string): State;
+			profile(filename: string): State;
+			progress(): State;
+			randomThreshold(channelType: 'All', LOWxHIGH: string): State;
+			randomThreshold(channelType: 'Intensity', LOWxHIGH: string): State;
+			randomThreshold(channelType: 'Red', LOWxHIGH: string): State;
+			randomThreshold(channelType: 'Green', LOWxHIGH: string): State;
+			randomThreshold(channelType: 'Blue', LOWxHIGH: string): State;
+			randomThreshold(channelType: 'Cyan', LOWxHIGH: string): State;
+			randomThreshold(channelType: 'Magenta', LOWxHIGH: string): State;
+			randomThreshold(channelType: 'Yellow', LOWxHIGH: string): State;
+			randomThreshold(channelType: 'Black', LOWxHIGH: string): State;
+			randomThreshold(channelType: 'Opacity', LOWxHIGH: string): State;
+			randomThreshold(channelType: string, LOWxHIGH: string): State;
+			quality(level: number): State;
+			raise(width: number, height: number): State;
+			recolor(matrix: string): State;
+			redPrimary(x: number, y: number): State;
+			region(width: number, height: number, x?: number, y?: number): State;
+			remote(): State;
+			render(): State;
+			repage(reset: '+'): State;
+			repage(reset: string): State;
+			repage(width: number, height: number, xoff: number, yoff: number, arg?: string): State;
+			sample(geometry: string): State;
+			samplingFactor(horizontalFactor: number, verticalFactor: number): State;
+			rawSize(width: number, height: number, offset?: number): State;
+			resample(horizontal: number, vertical: number): State;
+			/** Width and height are specified in percents */
+			resize(width: number, height: number, option: '%'): State;
+			/** Specify maximum area in pixels */
+			resize(width: number, height: number, option: '@'): State;
+			/** Ignore aspect ratio */
+			resize(width: number, height: number, option: '!'): State;
+			/** Width and height are minimum values */
+			resize(width: number, height: number, option: '^'): State;
+			/** Change dimensions only if image is smaller than width or height */
+			resize(width: number, height: number, option: '<'): State;
+			/** Change dimensions only if image is larger than width or height */
+			resize(width: number, height: number, option: '>'): State;
+			resize(width: number, height?: number, option?: string): State;
+			roll(horizontal: number, vertical: number): State;
+			rotate(backgroundColor: string, degrees: number): State;
+			scene(index: number): State;
+			scenes(start: number, end: number): State;
+			scale(width: number, height: number): State;
+			screen(): State;
+			segment(clustherThreshold: number, smoothingThreshold: number): State;
+			sepia(): State;
+			set(attribute: string, value: string): State;
+			setFormat(format: string): State;
+			shade(azimuth: number, elevation: number): State;
+			shadow(radius: number, sigma?: number): State;
+			sharedMemory(): State;
+			shave(width: number, height: number, percent?: boolean): State;
+			sharpen(radius: number, sigma?: number): State;
+			shear(xDegrees: number, yDegress: number): State;
+			silent(): State;
+			snaps(count: number): State;
+			solarize(threshold: number): State;
+			spread(amount: number): State;
+			stegano(offset: number): State;
+			stereo(): State;
+			strip(): State;
+			swirl(degrees: number): State;
+			textFont(font: string): State;
+			threshold(value: number, percent?: boolean): State;
+			thumb(width: number, height: number, outName: string, callback: WriteCallback): State;
+			thumb(width: number, height: number, outName: string, quality: number, callback: WriteCallback): State;
+			thumb(width: number, height: number, outName: string, quality: number, align: 'topleft', callback: WriteCallback): State;
+			thumb(width: number, height: number, outName: string, quality: number, align: 'center', callback: WriteCallback): State;
+			thumb(width: number, height: number, outName: string, quality: number, align: string, callback: WriteCallback): State;
+			tile(filename: string): State;
+			title(title: string): State;
+			transform(color: string): State;
+			transparent(color: string): State;
+			treeDepth(depth: number): State;
+			trim(): State;
+			type(type: 'Bilevel'): State;
+			type(type: 'Grayscale'): State;
+			type(type: 'Palette'): State;
+			type(type: 'PaletteMatte'): State;
+			type(type: 'TrueColor'): State;
+			type(type: 'TrueColorMatte'): State;
+			type(type: 'ColorSeparation'): State;
+			type(type: 'ColorSeparationMatte'): State;
+			type(type: 'Optimize'): State;
+			type(type: string): State;
+			update(seconds: number): State;
+			units(type: 'Undefined'): State;
+			units(type: 'PixelsPerInch'): State;
+			units(type: 'PixelsPerCentimeter'): State;
+			units(type: string): State;
+			unsharp(radius: number, sigma?: number, amount?: number, threshold?: number): State;
+			usePixmap(): State;
+			view(): State;
+			virtualPixel(method: 'Constant'): State;
+			virtualPixel(method: 'Edge'): State;
+			virtualPixel(method: 'Mirror'): State;
+			virtualPixel(method: 'Tile'): State;
+			virtualPixel(method: string): State;
+			visual(type: 'StaticGray'): State;
+			visual(type: 'GrayScale'): State;
+			visual(type: 'StaticColor'): State;
+			visual(type: 'PseudoColor'): State;
+			visual(type: 'TrueColor'): State;
+			visual(type: 'DirectColor'): State;
+			visual(type: 'default'): State;
+			visual(type: string): State;
+			watermark(brightness: number, saturation: number): State;
+			wave(amplitude: number, wavelength: number): State;
+			whitePoint(x: number, y: number): State;
+			whiteThreshold(intensity: number): State;
+			whiteThreshold(red: number, green: number, blue: number, opacity?: number): State;
+			window(id: string): State;
+			windowGroup(): State;
+
+			// Getters
+			color(callback: GetterCallback<number>): State;
+			depth(callback: GetterCallback<number>): State;
+			filesize(callback: GetterCallback<string>): State;
+			format(callback: GetterCallback<string>): State;
+			identify(callback: GetterCallback<ImageInfo>): State;
+			res(callback: GetterCallback<string>): State;
+			size(callback: GetterCallback<Dimensions>): State;
+			orientation(callback: GetterCallback<string>): State;
+
+			// Drawing Operations
+			draw(args: string): State;
+			drawArc(x0: number, y0: number, x1: number, y1: number, r0: number, r1: number): State;
+			drawBezier(x0: number, y0: number, x1: number, y1: number): State;
+			drawBezier(x0: number, y0: number, x1: number, y1: number, x2: number, y2: number): State;
+			drawBezier(x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, ...coords: number[]): State;
+			drawCircle(x0: number, y0: number, x1: number, y1: number): State;
+			drawEllipse(x0: number, y0: number, rx: number, ry: number, a0: number, a1: number): State;
+			drawLine(x0: number, y0: number, x1: number, y1: number): State;
+			drawPoint(x: number, y: number): State;
+			drawPolygon(x0: number, y0: number, x1: number, y1: number, x2: number, y2: number): State;
+			drawPolygon(x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, ...coords: number[]): State;
+			drawPolyline(x0: number, y0: number, x1: number, y1: number, x2: number, y2: number): State;
+			drawPolyline(x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, ...coords: number[]): State;
+			drawRectangle(x0: number, y0: number, x1: number, y1: number): State;
+			drawRectangle(x0: number, y0: number, x1: number, y1: number, rc: number): State;
+			drawRectangle(x0: number, y0: number, x1: number, y1: number, wc: number, hc: number): State;
+			drawText(x: number, y: number, text: string, gravity: 'NorthWest'): State;
+			drawText(x: number, y: number, text: string, gravity: 'North'): State;
+			drawText(x: number, y: number, text: string, gravity: 'NorthEast'): State;
+			drawText(x: number, y: number, text: string, gravity: 'West'): State;
+			drawText(x: number, y: number, text: string, gravity: 'Center'): State;
+			drawText(x: number, y: number, text: string, gravity: 'East'): State;
+			drawText(x: number, y: number, text: string, gravity: 'SouthWest'): State;
+			drawText(x: number, y: number, text: string, gravity: 'South'): State;
+			drawText(x: number, y: number, text: string, gravity: 'SouthEast'): State;
+			drawText(x: number, y: number, text: string, gravity?: string): State;
+			fill(color: string): State;
+			font(name: string, size?: number): State;
+			fontSize(size: number): State;
+			stroke(color: string, width?: number): State;
+			strokeWidth(width: number): State;
+			setDraw(property: 'color', x: number, y: number, method: 'point'): State;
+			setDraw(property: 'color', x: number, y: number, method: 'replace'): State;
+			setDraw(property: 'color', x: number, y: number, method: 'floodfill'): State;
+			setDraw(property: 'color', x: number, y: number, method: 'filltoborder'): State;
+			setDraw(property: 'color', x: number, y: number, method: 'reset'): State;
+			setDraw(property: 'matte', x: number, y: number, method: 'point'): State;
+			setDraw(property: 'matte', x: number, y: number, method: 'replace'): State;
+			setDraw(property: 'matte', x: number, y: number, method: 'floodfill'): State;
+			setDraw(property: 'matte', x: number, y: number, method: 'filltoborder'): State;
+			setDraw(property: 'matte', x: number, y: number, method: 'reset'): State;
+			setDraw(property: string, x: number, y: number, method: string): State;
+
+			// Commands
+			stream(callback?: WriteCallback): stream.PassThrough;
+			stream(format: string, callback?: WriteCallback): stream.PassThrough;
+			toBuffer(callback: (err: Error, buffer: Buffer) => any): stream.PassThrough;
+			toBuffer(format: string, callback: (err: Error, buffer: Buffer) => any): stream.PassThrough;
+			write(filename: string, callback: WriteCallback): void;
+		}
+
+		export interface SubClass {
+			(image: string): State;
+		}
+
+		export function compare(filename1: string, filename2: string, callback: CompareCallback): void;
+		export function compare(filename1: string, filename2: string, tolerance: number, callback: CompareCallback): void;
+		export function compare(filename1: string, filename2: string, options: CompareOptions, callback: CompareCallback): void;
+
+		export function subClass(options: ClassOptions): SubClass;
+	}
+
+	export = m;
+}