@types/gm/index.d.ts

// Type definitions for gm 1.25
// Project: https://github.com/aheckmann/gm
// Definitions by: Maarten van Vliet <https://github.com/maartenvanvliet>
//                 Vaclav Mlejnsky <https://github.com/mlejva>
//                 Dimitry Kooijmans <https://github.com/mrcageman>
//                 Dmitry Semigradsky <https://github.com/Semigradsky>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped

/// <reference types="node"/>

import stream = require('stream');

declare function m(stream: NodeJS.ReadableStream | Buffer | string, image?: string): m.State;
declare function m(width: number, height: number, color?: string): m.State;

declare namespace m {
    interface ClassOptions {
        appPath?: string | undefined;
        imageMagick?: string | boolean | undefined;
        nativeAutoOrient?: boolean | undefined;
        timeout?: string | number;
    }

    interface ChannelInfo<T> {
        Red: T;
        Green: T;
        Blue: T;
    }

    interface CompareOptions {
        file?: string | undefined;
        highlightColor?: string | undefined;
        highlightStyle?: HighlightStyle | undefined;
        tolerance?: number | undefined;
    }

    interface ColorStatistics {
        Minimum: string;
        Maximum: string;
        Mean: string;
        'Standard Deviation': string;
    }

    interface Dimensions {
        width: number;
        height: number;
    }

    interface GetterOptions {
       bufferStream?: boolean | undefined;
    }

    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 | undefined;
        'JPEG-Colorspace'?: string | undefined;
        'JPEG-Colorspace-Name'?: string | undefined;
        'JPEG-Sampling-factors'?: string | undefined;
        'Matte Color': string;
        Orientation: string;
        'Page geometry': string;
        path: string;

        'Profile-color'?: string | undefined;
        'Profile-iptc'?: {
            [key: string]: string;
        } | undefined;
        'Profile-EXIF'?: {
            [key: string]: string;
        } | undefined;
        'Profile-XMP'?: string | undefined;
        Resolution?: string | undefined;
        size: Dimensions;
        Signature: string;
        Software: string;
        Tainted: string;
        Type: string;
    }

    interface State {
        // Image Operations
        adjoin(): State;
        affine(matrix: string): State;
        antialias(enable: boolean): State;
        append(ltr?: boolean): State;
        append(image: string | string[], ltr?: boolean): State;
        authenticate(password: string): State;
        autoOrient(): State;
        average(): State;
        backdrop(): State;
        background(color: string): 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: NamedColor | 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' | 'private' | string): State;
        colors(colors: number): State;
        colorspace(space: ColorSpace | string): State;
        command(customCommand: string): State;
        compose(operator: ComposeOperator | string): State;
        composite(changeImagePath: string, maskImagePath?: string): State;
        compress(type: CompressionType | 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(value: string): State;
        delay(centiseconds: number): State;
        density(width: number, height: number): State;
        despeckle(): State;
        displace(horizontal: number, vertical: number): State;
        display(xServer: string): State;
        dispose(method: DisposeMethod | string): State;
        dissolve(percent: number): State;
        dither(enable?: boolean): State;
        edge(radius?: number): State;
        emboss(radius?: number): State;
        encoding(encoding: Encoding | string): State;
        endian(type: EndianType | string): State;
        enhance(): State;
        equalize(): State;
        extent(width: number, height: number, options?: string): State;
        file(filename: string): State;
        filter(type: FilterType | 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;
        geometry(width: number, height?: number, option?: ResizeOption): State;
        geometry(geometry: string): State;
        greenPrimary(x: number, y: number): State;
        gravity(direction: GravityDirection | string): State;
        highlightColor(color: string): State;
        highlightStyle(style: HighlightStyle | string): State;
        iconGeometry(geometry: string): State;
        implode(factor?: number): State;
        in(...customArguments: string[]): State;
        intent(type: IntentType | string): State;
        interlace(type: InterlaceType | 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: LimitType | string, val: string): State;
        list(type: ListType | string): 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: OperationMode | string): State;
        modulate(b: number, s?: number, h?: number): State;
        monitor(): State;
        monochrome(): State;
        montage(otherImg: string): State;
        morph(otherImg: string | string[], outName: string, callback?: WriteCallback): State;
        mosaic(): State;
        motionBlur(radius: number, sigma?: number, angle?: number): State;
        name(): State;
        negative(): State;
        noise(type: NoiseType | string | number): State;
        noop(): State;
        normalize(): State;
        opaque(color: string): State;
        operator(channel: string, operator: ChannelOperator | string, rvalue: number, percent?: boolean): State;
        orderedDither(channelType: ChannelType | string, NxN: string): State;
        out(...customArguments: string[]): State;
        outputDirectory(directory: string): 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: PreviewType | string): State;
        paint(radius: number): State;
        process(command: string): State;
        profile(filename: string): State;
        progress(): State;
        randomThreshold(channelType: ChannelType, 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: '+' | 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;
        resize(width: number, height: number, option: ResizeOption): State;
        resize(width: number, height?: number, option?: ResizeOption): 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;
        /** change the specified frame. */
        selectFrame(frame: 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;
        texture(filename: 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' | 'center' | string, callback: WriteCallback): State;
        thumbnail(width: number, height: number, options?: ResizeOption): 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: ImageType | string): State;
        update(seconds: number): State;
        units(type: UnitType | string): State;
        unsharp(radius: number, sigma?: number, amount?: number, threshold?: number): State;
        usePixmap(): State;
        view(): State;
        virtualPixel(method: VirtualPixelMethod | string): State;
        visual(type: VisualType | 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;
        color(opts: GetterOptions, callback: GetterCallback<number>): State;
        depth(callback: GetterCallback<number>): State;
        depth(opts: GetterOptions, callback: GetterCallback<number>): State;
        filesize(callback: GetterCallback<string>): State;
        filesize(opts: GetterOptions, callback: GetterCallback<string>): State;
        format(callback: GetterCallback<string>): State;
        format(opts: GetterOptions, callback: GetterCallback<string>): State;
        identify(callback: GetterCallback<ImageInfo>): State;
        identify(format: string, callback: GetterCallback<string>): State;
        identify(opts: GetterOptions, callback: GetterCallback<ImageInfo>): State;
        res(callback: GetterCallback<string>): State;
        res(opts: GetterOptions, callback: GetterCallback<string>): State;
        size(callback: GetterCallback<Dimensions>): State;
        size(opts: GetterOptions, callback: GetterCallback<Dimensions>): State;
        orientation(callback: GetterCallback<string>): State;
        orientation(opts: GetterOptions, 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(coord0: [number, number], coord1: [number, number], ...coords: Array<[number, 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(coord0: [number, number], coord1: [number, number], coord2: [number, number], ...coords: Array<[number, number]>): State;
        drawPolyline(coord0: [number, number], coord1: [number, number], coord2: [number, number], ...coords: Array<[number, number]>): State;
        drawRectangle(x0: number, y0: number, x1: number, y1: number, wc?: number, hc?: number): State;
        drawText(x: number, y: number, text: string, gravity?: GravityDirection | 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: SetDrawProperty | string, x: number, y: number, method: SetDrawMethod | string): State;

        // Commands
        stream(callback?: WriteCallback): stream.PassThrough;
        stream(format: string, callback?: WriteCallback): stream.PassThrough;
        toBuffer(callback: (err: Error|null, buffer: Buffer) => any): stream.PassThrough;
        toBuffer(format: string, callback: (err: Error|null, buffer: Buffer) => any): stream.PassThrough;
        write(filename: string, callback: WriteCallback): void;
    }

    interface SubClass {
        (image: string): State;
        (stream: NodeJS.ReadableStream | Buffer, image?: string): State;
        (width: number, height: number, color?: string): State;
    }

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

    function subClass(options: ClassOptions): SubClass;

    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 = 'All'
        | 'Intensity'
        | 'Red'
        | 'Green'
        | 'Blue'
        | 'Cyan'
        | 'Magenta'
        | 'Yellow'
        | 'Black'
        | 'Opacity';

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

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

    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 = 'None'
        | 'BZip'
        | 'Fax'
        | 'Group4'
        | 'JPEG'
        | 'Lossless'
        | 'LZW'
        | 'RLE'
        | 'Zip'
        | 'LZMA';

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    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 = '%' /** 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 */
        | '>'; /** Change dimensions only if image is larger than width or height */

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

    type SetDrawProperty = 'color' | 'matte';

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

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

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

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

export = m;