mirror of
https://github.com/zhigang1992/DefinitelyTyped.git
synced 2026-04-23 12:56:46 +08:00
624 lines
26 KiB
TypeScript
624 lines
26 KiB
TypeScript
// 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;
|
|
}
|