gulp-svg2png

gulp-svg2png

Version 2.0.2
Published 8 years ago
4 dependencies
MIT license

Install

npm i gulp-svg2png

yarn add gulp-svg2png

pnpm add gulp-svg2png

Overview

A gulp plugin for converting SVGs to PNGs.

Index

Namespaces

assert
buffer
- INSPECT_MAX_BYTES
chalk
- ch
child_process
cluster
crypto
dgram
dns
domain
- create()
- Domain
events
- EventEmitter
fs
gulp-util
http
https
mocha
- Mocha
net
os
path
path.posix
path.win32
punycode
querystring
readline
repl
- ReplOptions
- start()
stream
string_decoder
- NodeStringDecoder
- StringDecoder
through2
tls
tty
url
util
vinyl
- File
vm
zlib

Namespaces

namespace assert

module 'assert' {}

variable doesNotThrow

var doesNotThrow: {
    (block: Function, message?: string): void;
    (block: Function, error: Function, message?: string): void;
    (block: Function, error: RegExp, message?: string): void;
    (block: Function, error: (err: any) => boolean, message?: string): void;
};

variable throws

var throws: {
    (block: Function, message?: string): void;
    (block: Function, error: Function, message?: string): void;
    (block: Function, error: RegExp, message?: string): void;
    (block: Function, error: (err: any) => boolean, message?: string): void;
};

function deepEqual

deepEqual: (actual: any, expected: any, message?: string) => void;

function equal

equal: (actual: any, expected: any, message?: string) => void;

function fail

fail: (
    actual?: any,
    expected?: any,
    message?: string,
    operator?: string
) => void;

function ifError

ifError: (value: any) => void;

function internal

internal: typeof internal;

function notDeepEqual

notDeepEqual: (acutal: any, expected: any, message?: string) => void;

function notEqual

notEqual: (actual: any, expected: any, message?: string) => void;

function notStrictEqual

notStrictEqual: (actual: any, expected: any, message?: string) => void;

function ok

ok: (value: any, message?: string) => void;

function strictEqual

strictEqual: (actual: any, expected: any, message?: string) => void;

class AssertionError

class AssertionError implements Error {}

constructor

constructor(options?: {
    message?: string;
    actual?: any;
    expected?: any;
    operator?: string;
    stackStartFunction?: Function;
});

property actual

actual: any;

property expected

expected: any;

property generatedMessage

generatedMessage: boolean;

property message

message: string;

property name

name: string;

property operator

operator: string;

namespace buffer

module 'buffer' {}

********************************************** * MODULES * * **********************************************

variable INSPECT_MAX_BYTES

var INSPECT_MAX_BYTES: number;

namespace chalk

module 'chalk' {}

variable ch

var ch: Chalk.ChalkModule;

namespace child_process

module 'child_process' {}

function exec

exec: {
    (
        command: string,
        options: {
            cwd?: string;
            stdio?: any;
            customFds?: any;
            env?: any;
            encoding?: string;
            timeout?: number;
            maxBuffer?: number;
            killSignal?: string;
        },
        callback?: (error: Error, stdout: Buffer, stderr: Buffer) => void
    ): ChildProcess;
    (
        command: string,
        callback?: (error: Error, stdout: Buffer, stderr: Buffer) => void
    ): ChildProcess;
    (
        command: string,
        options: {
            cwd?: string;
            stdio?: any;
            customFds?: any;
            env?: any;
            encoding?: string;
            timeout?: number;
            maxBuffer?: number;
            killSignal?: string;
        },
        callback?: (error: Error, stdout: Buffer, stderr: Buffer) => void
    ): ChildProcess;
    (
        command: string,
        callback?: (error: Error, stdout: Buffer, stderr: Buffer) => void
    ): ChildProcess;
};

function execFile

execFile: {
    (
        file: string,
        callback?: (error: Error, stdout: Buffer, stderr: Buffer) => void
    ): ChildProcess;
    (
        file: string,
        args?: string[],
        callback?: (error: Error, stdout: Buffer, stderr: Buffer) => void
    ): ChildProcess;
    (
        file: string,
        args?: string[],
        options?: {
            cwd?: string;
            stdio?: any;
            customFds?: any;
            env?: any;
            encoding?: string;
            timeout?: number;
            maxBuffer?: string;
            killSignal?: string;
        },
        callback?: (error: Error, stdout: Buffer, stderr: Buffer) => void
    ): ChildProcess;
    (
        file: string,
        callback?: (error: Error, stdout: Buffer, stderr: Buffer) => void
    ): ChildProcess;
    (
        file: string,
        args?: string[],
        callback?: (error: Error, stdout: Buffer, stderr: Buffer) => void
    ): ChildProcess;
    (
        file: string,
        args?: string[],
        options?: {
            cwd?: string;
            stdio?: any;
            customFds?: any;
            env?: any;
            encoding?: string;
            timeout?: number;
            maxBuffer?: string;
            killSignal?: string;
        },
        callback?: (error: Error, stdout: Buffer, stderr: Buffer) => void
    ): ChildProcess;
};

function execFileSync

execFileSync: {
    (
        command: string,
        args?: string[],
        options?: {
            cwd?: string;
            input?: string | Buffer;
            stdio?: any;
            env?: any;
            uid?: number;
            gid?: number;
            timeout?: number;
            maxBuffer?: number;
            killSignal?: string;
            encoding?: string;
        }
    ): ChildProcess;
    (
        command: string,
        args?: string[],
        options?: {
            cwd?: string;
            input?: string | Buffer;
            stdio?: any;
            env?: any;
            uid?: number;
            gid?: number;
            timeout?: number;
            maxBuffer?: number;
            killSignal?: string;
            encoding?: string;
        }
    ): ChildProcess;
};

function execSync

execSync: {
    (
        command: string,
        options?: {
            cwd?: string;
            input?: string | Buffer;
            stdio?: any;
            env?: any;
            uid?: number;
            gid?: number;
            timeout?: number;
            maxBuffer?: number;
            killSignal?: string;
            encoding?: string;
        }
    ): ChildProcess;
    (
        command: string,
        options?: {
            cwd?: string;
            input?: string | Buffer;
            stdio?: any;
            env?: any;
            uid?: number;
            gid?: number;
            timeout?: number;
            maxBuffer?: number;
            killSignal?: string;
            encoding?: string;
        }
    ): ChildProcess;
};

function fork

fork: {
    (
        modulePath: string,
        args?: string[],
        options?: { cwd?: string; env?: any; encoding?: string }
    ): ChildProcess;
    (
        modulePath: string,
        args?: string[],
        options?: { cwd?: string; env?: any; encoding?: string }
    ): ChildProcess;
};

function spawn

spawn: {
    (
        command: string,
        args?: string[],
        options?: {
            cwd?: string;
            stdio?: any;
            custom?: any;
            env?: any;
            detached?: boolean;
        }
    ): ChildProcess;
    (
        command: string,
        args?: string[],
        options?: {
            cwd?: string;
            stdio?: any;
            custom?: any;
            env?: any;
            detached?: boolean;
        }
    ): ChildProcess;
};

interface ChildProcess

interface ChildProcess extends events.EventEmitter {}

property pid

pid: number;

property stderr

stderr: stream.Readable;

property stdin

stdin: stream.Writable;

property stdout

stdout: stream.Readable;

method disconnect

disconnect: { (): void; (): void };

method kill

kill: { (signal?: string): void; (signal?: string): void };

method send

send: {
    (message: any, sendHandle?: any): void;
    (message: any, sendHandle?: any): void;
};

namespace cluster

module 'cluster' {}

variable isMaster

var isMaster: boolean;

variable isWorker

var isWorker: boolean;

variable settings

var settings: ClusterSettings;

variable worker

var worker: Worker;

variable workers

var workers: Worker[];

function addListener

addListener: {
    (event: string, listener: Function): void;
    (event: string, listener: Function): void;
};

function disconnect

disconnect: { (callback?: Function): void; (callback?: Function): void };

function emit

emit: {
    (event: string, ...args: any[]): boolean;
    (event: string, ...args: any[]): boolean;
};

function fork

fork: { (env?: any): Worker; (env?: any): Worker };

function listeners

listeners: { (event: string): Function[]; (event: string): Function[] };

function on

on: {
    (event: string, listener: Function): any;
    (event: string, listener: Function): any;
};

function once

once: {
    (event: string, listener: Function): void;
    (event: string, listener: Function): void;
};

function removeAllListeners

removeAllListeners: { (event?: string): void; (event?: string): void };

function removeListener

removeListener: {
    (event: string, listener: Function): void;
    (event: string, listener: Function): void;
};

function setMaxListeners

setMaxListeners: { (n: number): void; (n: number): void };

function setupMaster

setupMaster: {
    (settings?: ClusterSettings): void;
    (settings?: ClusterSettings): void;
};

class Worker

class Worker extends events.EventEmitter {}

property id

id: string;

property process

process: child.ChildProcess;

property suicide

suicide: boolean;

method destroy

destroy: (signal?: string) => void;

method disconnect

disconnect: () => void;

method kill

kill: (signal?: string) => void;

method send

send: (message: any, sendHandle?: any) => void;

interface ClusterSettings

interface ClusterSettings {}

property args

args?: string[];

property exec

exec?: string;

property silent

silent?: boolean;

namespace crypto

module 'crypto' {}

function createCipher

createCipher: {
    (algorithm: string, password: any): Cipher;
    (algorithm: string, password: any): Cipher;
};

function createCipheriv

createCipheriv: {
    (algorithm: string, key: any, iv: any): Cipher;
    (algorithm: string, key: any, iv: any): Cipher;
};

function createCredentials

createCredentials: {
    (details: CredentialDetails): Credentials;
    (details: CredentialDetails): Credentials;
};

function createDecipher

createDecipher: {
    (algorithm: string, password: any): Decipher;
    (algorithm: string, password: any): Decipher;
};

function createDecipheriv

createDecipheriv: {
    (algorithm: string, key: any, iv: any): Decipher;
    (algorithm: string, key: any, iv: any): Decipher;
};

function createDiffieHellman

createDiffieHellman: {
    (prime_length: number): DiffieHellman;
    (prime: number, encoding?: string): DiffieHellman;
    (prime_length: number): DiffieHellman;
    (prime: number, encoding?: string): DiffieHellman;
};

function createHash

createHash: { (algorithm: string): Hash; (algorithm: string): Hash };

function createHmac

createHmac: {
    (algorithm: string, key: string): Hmac;
    (algorithm: string, key: Buffer): Hmac;
    (algorithm: string, key: string): Hmac;
    (algorithm: string, key: Buffer): Hmac;
};

function createSign

createSign: { (algorithm: string): Signer; (algorithm: string): Signer };

function createVerify

createVerify: { (algorith: string): Verify; (algorith: string): Verify };

function getDiffieHellman

getDiffieHellman: {
    (group_name: string): DiffieHellman;
    (group_name: string): DiffieHellman;
};

function pbkdf2

pbkdf2: {
    (
        password: string,
        salt: string,
        iterations: number,
        keylen: number,
        callback: (err: Error, derivedKey: Buffer) => any
    ): void;
    (
        password: string,
        salt: string,
        iterations: number,
        keylen: number,
        callback: (err: Error, derivedKey: Buffer) => any
    ): void;
};

function pbkdf2Sync

pbkdf2Sync: {
    (password: string, salt: string, iterations: number, keylen: number): Buffer;
    (password: string, salt: string, iterations: number, keylen: number): Buffer;
};

function pseudoRandomBytes

pseudoRandomBytes: {
    (size: number): Buffer;
    (size: number, callback: (err: Error, buf: Buffer) => void): void;
    (size: number): Buffer;
    (size: number, callback: (err: Error, buf: Buffer) => void): void;
};

function randomBytes

randomBytes: {
    (size: number): Buffer;
    (size: number, callback: (err: Error, buf: Buffer) => void): void;
    (size: number): Buffer;
    (size: number, callback: (err: Error, buf: Buffer) => void): void;
};

interface Cipher

interface Cipher {}

method final

final: {
    (): Buffer;
    (output_encoding: string): string;
    (): Buffer;
    (output_encoding: string): string;
};

method setAutoPadding

setAutoPadding: { (auto_padding: boolean): void; (auto_padding: boolean): void };

method update

update: {
    (data: Buffer): Buffer;
    (data: string, input_encoding?: string, output_encoding?: string): string;
    (data: Buffer): Buffer;
    (data: string, input_encoding?: string, output_encoding?: string): string;
};

interface CredentialDetails

interface CredentialDetails {}

property ca

ca: any;

property cert

cert: string;

property ciphers

ciphers: string;

property crl

crl: any;

property key

key: string;

property passphrase

passphrase: string;

property pfx

pfx: string;

interface Credentials

interface Credentials {}

property context

context?: any;

interface Decipher

interface Decipher {}

method final

final: {
    (): Buffer;
    (output_encoding: string): string;
    (): Buffer;
    (output_encoding: string): string;
};

method setAutoPadding

setAutoPadding: { (auto_padding: boolean): void; (auto_padding: boolean): void };

method update

update: {
    (data: Buffer): Buffer;
    (data: string, input_encoding?: string, output_encoding?: string): string;
    (data: Buffer): Buffer;
    (data: string, input_encoding?: string, output_encoding?: string): string;
};

interface DiffieHellman

interface DiffieHellman {}

method computeSecret

computeSecret: {
    (
        other_public_key: string,
        input_encoding?: string,
        output_encoding?: string
    ): string;
    (
        other_public_key: string,
        input_encoding?: string,
        output_encoding?: string
    ): string;
};

method generateKeys

generateKeys: { (encoding?: string): string; (encoding?: string): string };

method getGenerator

getGenerator: { (encoding: string): string; (encoding: string): string };

method getPrime

getPrime: { (encoding?: string): string; (encoding?: string): string };

method getPrivateKey

getPrivateKey: { (encoding?: string): string; (encoding?: string): string };

method getPublicKey

getPublicKey: { (encoding?: string): string; (encoding?: string): string };

method setPrivateKey

setPrivateKey: {
    (public_key: string, encoding?: string): void;
    (public_key: string, encoding?: string): void;
};

method setPublicKey

setPublicKey: {
    (public_key: string, encoding?: string): void;
    (public_key: string, encoding?: string): void;
};

interface Hash

interface Hash {}

method digest

digest: {
    (encoding: 'buffer'): Buffer;
    (encoding: string): any;
    (): Buffer;
    (encoding: 'buffer'): Buffer;
    (encoding: string): any;
    (): Buffer;
};

method update

update: {
    (data: any, input_encoding?: string): Hash;
    (data: any, input_encoding?: string): Hash;
};

interface Hmac

interface Hmac {}

method digest

digest: {
    (encoding: 'buffer'): Buffer;
    (encoding: string): any;
    (): Buffer;
    (encoding: 'buffer'): Buffer;
    (encoding: string): any;
    (): Buffer;
};

method update

update: {
    (data: any, input_encoding?: string): Hmac;
    (data: any, input_encoding?: string): Hmac;
};

interface Signer

interface Signer {}

method sign

sign: {
    (private_key: string, output_format: string): string;
    (private_key: string, output_format: string): string;
};

method update

update: { (data: any): void; (data: any): void };

interface Verify

interface Verify {}

method update

update: { (data: any): void; (data: any): void };

method verify

verify: {
    (object: string, signature: string, signature_format?: string): boolean;
    (object: string, signature: string, signature_format?: string): boolean;
};

namespace dgram

module 'dgram' {}

function createSocket

createSocket: {
    (type: string, callback?: (msg: Buffer, rinfo: RemoteInfo) => void): Socket;
    (type: string, callback?: (msg: Buffer, rinfo: RemoteInfo) => void): Socket;
};

interface AddressInfo

interface AddressInfo {}

property address

address: string;

property family

family: string;

property port

port: number;

interface RemoteInfo

interface RemoteInfo {}

property address

address: string;

property port

port: number;

property size

size: number;

interface Socket

interface Socket extends events.EventEmitter {}

method addMembership

addMembership: {
    (multicastAddress: string, multicastInterface?: string): void;
    (multicastAddress: string, multicastInterface?: string): void;
};

method address

address: { (): AddressInfo; (): AddressInfo };

method bind

bind: {
    (port: number, address?: string, callback?: () => void): void;
    (port: number, address?: string, callback?: () => void): void;
};

method close

close: { (): void; (): void };

method dropMembership

dropMembership: {
    (multicastAddress: string, multicastInterface?: string): void;
    (multicastAddress: string, multicastInterface?: string): void;
};

method send

send: {
    (
        buf: Buffer,
        offset: number,
        length: number,
        port: number,
        address: string,
        callback?: (error: Error, bytes: number) => void
    ): void;
    (
        buf: Buffer,
        offset: number,
        length: number,
        port: number,
        address: string,
        callback?: (error: Error, bytes: number) => void
    ): void;
};

method setBroadcast

setBroadcast: { (flag: boolean): void; (flag: boolean): void };

method setMulticastLoopback

setMulticastLoopback: { (flag: boolean): void; (flag: boolean): void };

method setMulticastTTL

setMulticastTTL: { (ttl: number): void; (ttl: number): void };

namespace dns

module 'dns' {}

function lookup

lookup: {
    (
        domain: string,
        family: number,
        callback: (err: Error, address: string, family: number) => void
    ): string;
    (
        domain: string,
        callback: (err: Error, address: string, family: number) => void
    ): string;
    (
        domain: string,
        family: number,
        callback: (err: Error, address: string, family: number) => void
    ): string;
    (
        domain: string,
        callback: (err: Error, address: string, family: number) => void
    ): string;
};

function resolve

resolve: {
    (
        domain: string,
        rrtype: string,
        callback: (err: Error, addresses: string[]) => void
    ): string[];
    (domain: string, callback: (err: Error, addresses: string[]) => void): string[];
    (
        domain: string,
        rrtype: string,
        callback: (err: Error, addresses: string[]) => void
    ): string[];
    (domain: string, callback: (err: Error, addresses: string[]) => void): string[];
};

function resolve4

resolve4: {
    (domain: string, callback: (err: Error, addresses: string[]) => void): string[];
    (domain: string, callback: (err: Error, addresses: string[]) => void): string[];
};

function resolve6

resolve6: {
    (domain: string, callback: (err: Error, addresses: string[]) => void): string[];
    (domain: string, callback: (err: Error, addresses: string[]) => void): string[];
};

function resolveCname

resolveCname: {
    (domain: string, callback: (err: Error, addresses: string[]) => void): string[];
    (domain: string, callback: (err: Error, addresses: string[]) => void): string[];
};

function resolveMx

resolveMx: {
    (domain: string, callback: (err: Error, addresses: string[]) => void): string[];
    (domain: string, callback: (err: Error, addresses: string[]) => void): string[];
};

function resolveNs

resolveNs: {
    (domain: string, callback: (err: Error, addresses: string[]) => void): string[];
    (domain: string, callback: (err: Error, addresses: string[]) => void): string[];
};

function resolveSrv

resolveSrv: {
    (domain: string, callback: (err: Error, addresses: string[]) => void): string[];
    (domain: string, callback: (err: Error, addresses: string[]) => void): string[];
};

function resolveTxt

resolveTxt: {
    (domain: string, callback: (err: Error, addresses: string[]) => void): string[];
    (domain: string, callback: (err: Error, addresses: string[]) => void): string[];
};

function reverse

reverse: {
    (ip: string, callback: (err: Error, domains: string[]) => void): string[];
    (ip: string, callback: (err: Error, domains: string[]) => void): string[];
};

namespace domain

module 'domain' {}

function create

create: { (): Domain; (): Domain };

class Domain

class Domain extends events.EventEmitter {}

method add

add: (emitter: events.EventEmitter) => void;

method addListener

addListener: (event: string, listener: Function) => Domain;

method bind

bind: (cb: (err: Error, data: any) => any) => any;

method dispose

dispose: () => void;

method intercept

intercept: (cb: (data: any) => any) => any;

method on

on: (event: string, listener: Function) => Domain;

method once

once: (event: string, listener: Function) => Domain;

method remove

remove: (emitter: events.EventEmitter) => void;

method removeAllListeners

removeAllListeners: (event?: string) => Domain;

method removeListener

removeListener: (event: string, listener: Function) => Domain;

method run

run: (fn: Function) => void;

namespace events

module 'events' {}

class EventEmitter

class EventEmitter implements NodeJS.EventEmitter {}

method addListener

addListener: (event: string, listener: Function) => EventEmitter;

method emit

emit: (event: string, ...args: any[]) => boolean;

method listenerCount

static listenerCount: (emitter: EventEmitter, event: string) => number;

method listeners

listeners: (event: string) => Function[];

method on

on: (event: string, listener: Function) => EventEmitter;

method once

once: (event: string, listener: Function) => EventEmitter;

method removeAllListeners

removeAllListeners: (event?: string) => EventEmitter;

method removeListener

removeListener: (event: string, listener: Function) => EventEmitter;

method setMaxListeners

setMaxListeners: (n: number) => void;

namespace fs

module 'fs' {}

function appendFile

appendFile: {
    (
        filename: string,
        data: any,
        options: { encoding?: string; mode?: number; flag?: string },
        callback?: (err: NodeJS.ErrnoException) => void
    ): void;
    (
        filename: string,
        data: any,
        options: { encoding?: string; mode?: string; flag?: string },
        callback?: (err: NodeJS.ErrnoException) => void
    ): void;
    (
        filename: string,
        data: any,
        callback?: (err: NodeJS.ErrnoException) => void
    ): void;
    (
        filename: string,
        data: any,
        options: { encoding?: string; mode?: number; flag?: string },
        callback?: (err: NodeJS.ErrnoException) => void
    ): void;
    (
        filename: string,
        data: any,
        options: { encoding?: string; mode?: string; flag?: string },
        callback?: (err: NodeJS.ErrnoException) => void
    ): void;
    (
        filename: string,
        data: any,
        callback?: (err: NodeJS.ErrnoException) => void
    ): void;
};

function appendFileSync

appendFileSync: {
    (
        filename: string,
        data: any,
        options?: { encoding?: string; mode?: number; flag?: string }
    ): void;
    (
        filename: string,
        data: any,
        options?: { encoding?: string; mode?: string; flag?: string }
    ): void;
    (
        filename: string,
        data: any,
        options?: { encoding?: string; mode?: number; flag?: string }
    ): void;
    (
        filename: string,
        data: any,
        options?: { encoding?: string; mode?: string; flag?: string }
    ): void;
};

function chmod

chmod: {
    (
        path: string,
        mode: number,
        callback?: (err?: NodeJS.ErrnoException) => void
    ): void;
    (
        path: string,
        mode: string,
        callback?: (err?: NodeJS.ErrnoException) => void
    ): void;
    (
        path: string,
        mode: number,
        callback?: (err?: NodeJS.ErrnoException) => void
    ): void;
    (
        path: string,
        mode: string,
        callback?: (err?: NodeJS.ErrnoException) => void
    ): void;
};

function chmodSync

chmodSync: {
    (path: string, mode: number): void;
    (path: string, mode: string): void;
    (path: string, mode: number): void;
    (path: string, mode: string): void;
};

function chown

chown: {
    (
        path: string,
        uid: number,
        gid: number,
        callback?: (err?: NodeJS.ErrnoException) => void
    ): void;
    (
        path: string,
        uid: number,
        gid: number,
        callback?: (err?: NodeJS.ErrnoException) => void
    ): void;
};

function chownSync

chownSync: {
    (path: string, uid: number, gid: number): void;
    (path: string, uid: number, gid: number): void;
};

function close

close: {
    (fd: number, callback?: (err?: NodeJS.ErrnoException) => void): void;
    (fd: number, callback?: (err?: NodeJS.ErrnoException) => void): void;
};

function closeSync

closeSync: { (fd: number): void; (fd: number): void };

function createReadStream

createReadStream: {
    (
        path: string,
        options?: {
            flags?: string;
            encoding?: string;
            fd?: string;
            mode?: number;
            bufferSize?: number;
        }
    ): ReadStream;
    (
        path: string,
        options?: {
            flags?: string;
            encoding?: string;
            fd?: string;
            mode?: string;
            bufferSize?: number;
        }
    ): ReadStream;
    (
        path: string,
        options?: {
            flags?: string;
            encoding?: string;
            fd?: string;
            mode?: number;
            bufferSize?: number;
        }
    ): ReadStream;
    (
        path: string,
        options?: {
            flags?: string;
            encoding?: string;
            fd?: string;
            mode?: string;
            bufferSize?: number;
        }
    ): ReadStream;
};

function createWriteStream

createWriteStream: {
    (
        path: string,
        options?: { flags?: string; encoding?: string; string?: string }
    ): WriteStream;
    (
        path: string,
        options?: { flags?: string; encoding?: string; string?: string }
    ): WriteStream;
};

function exists

exists: {
    (path: string, callback?: (exists: boolean) => void): void;
    (path: string, callback?: (exists: boolean) => void): void;
};

function existsSync

existsSync: { (path: string): boolean; (path: string): boolean };

function fchmod

fchmod: {
    (
        fd: number,
        mode: number,
        callback?: (err?: NodeJS.ErrnoException) => void
    ): void;
    (
        fd: number,
        mode: string,
        callback?: (err?: NodeJS.ErrnoException) => void
    ): void;
    (
        fd: number,
        mode: number,
        callback?: (err?: NodeJS.ErrnoException) => void
    ): void;
    (
        fd: number,
        mode: string,
        callback?: (err?: NodeJS.ErrnoException) => void
    ): void;
};

function fchmodSync

fchmodSync: {
    (fd: number, mode: number): void;
    (fd: number, mode: string): void;
    (fd: number, mode: number): void;
    (fd: number, mode: string): void;
};

function fchown

fchown: {
    (
        fd: number,
        uid: number,
        gid: number,
        callback?: (err?: NodeJS.ErrnoException) => void
    ): void;
    (
        fd: number,
        uid: number,
        gid: number,
        callback?: (err?: NodeJS.ErrnoException) => void
    ): void;
};

function fchownSync

fchownSync: {
    (fd: number, uid: number, gid: number): void;
    (fd: number, uid: number, gid: number): void;
};

function fstat

fstat: {
    (fd: number, callback?: (err: NodeJS.ErrnoException, stats: Stats) => any): void;
    (fd: number, callback?: (err: NodeJS.ErrnoException, stats: Stats) => any): void;
};

function fstatSync

fstatSync: { (fd: number): Stats; (fd: number): Stats };

function fsync

fsync: {
    (fd: number, callback?: (err?: NodeJS.ErrnoException) => void): void;
    (fd: number, callback?: (err?: NodeJS.ErrnoException) => void): void;
};

function fsyncSync

fsyncSync: { (fd: number): void; (fd: number): void };

function ftruncate

ftruncate: {
    (fd: number, callback?: (err?: NodeJS.ErrnoException) => void): void;
    (
        fd: number,
        len: number,
        callback?: (err?: NodeJS.ErrnoException) => void
    ): void;
    (fd: number, callback?: (err?: NodeJS.ErrnoException) => void): void;
    (
        fd: number,
        len: number,
        callback?: (err?: NodeJS.ErrnoException) => void
    ): void;
};

function ftruncateSync

ftruncateSync: {
    (fd: number, len?: number): void;
    (fd: number, len?: number): void;
};

function futimes

futimes: {
    (
        fd: number,
        atime: number,
        mtime: number,
        callback?: (err?: NodeJS.ErrnoException) => void
    ): void;
    (
        fd: number,
        atime: Date,
        mtime: Date,
        callback?: (err?: NodeJS.ErrnoException) => void
    ): void;
    (
        fd: number,
        atime: number,
        mtime: number,
        callback?: (err?: NodeJS.ErrnoException) => void
    ): void;
    (
        fd: number,
        atime: Date,
        mtime: Date,
        callback?: (err?: NodeJS.ErrnoException) => void
    ): void;
};

function futimesSync

futimesSync: {
    (fd: number, atime: number, mtime: number): void;
    (fd: number, atime: Date, mtime: Date): void;
    (fd: number, atime: number, mtime: number): void;
    (fd: number, atime: Date, mtime: Date): void;
};

function lchmod

lchmod: {
    (
        path: string,
        mode: number,
        callback?: (err?: NodeJS.ErrnoException) => void
    ): void;
    (
        path: string,
        mode: string,
        callback?: (err?: NodeJS.ErrnoException) => void
    ): void;
    (
        path: string,
        mode: number,
        callback?: (err?: NodeJS.ErrnoException) => void
    ): void;
    (
        path: string,
        mode: string,
        callback?: (err?: NodeJS.ErrnoException) => void
    ): void;
};

function lchmodSync

lchmodSync: {
    (path: string, mode: number): void;
    (path: string, mode: string): void;
    (path: string, mode: number): void;
    (path: string, mode: string): void;
};

function lchown

lchown: {
    (
        path: string,
        uid: number,
        gid: number,
        callback?: (err?: NodeJS.ErrnoException) => void
    ): void;
    (
        path: string,
        uid: number,
        gid: number,
        callback?: (err?: NodeJS.ErrnoException) => void
    ): void;
};

function lchownSync

lchownSync: {
    (path: string, uid: number, gid: number): void;
    (path: string, uid: number, gid: number): void;
};

function link

link: {
    (
        srcpath: string,
        dstpath: string,
        callback?: (err?: NodeJS.ErrnoException) => void
    ): void;
    (
        srcpath: string,
        dstpath: string,
        callback?: (err?: NodeJS.ErrnoException) => void
    ): void;
};

function linkSync

linkSync: {
    (srcpath: string, dstpath: string): void;
    (srcpath: string, dstpath: string): void;
};

function lstat

lstat: {
    (
        path: string,
        callback?: (err: NodeJS.ErrnoException, stats: Stats) => any
    ): void;
    (
        path: string,
        callback?: (err: NodeJS.ErrnoException, stats: Stats) => any
    ): void;
};

function lstatSync

lstatSync: { (path: string): Stats; (path: string): Stats };

function mkdir

mkdir: {
    (path: string, callback?: (err?: NodeJS.ErrnoException) => void): void;
    (
        path: string,
        mode: number,
        callback?: (err?: NodeJS.ErrnoException) => void
    ): void;
    (
        path: string,
        mode: string,
        callback?: (err?: NodeJS.ErrnoException) => void
    ): void;
    (path: string, callback?: (err?: NodeJS.ErrnoException) => void): void;
    (
        path: string,
        mode: number,
        callback?: (err?: NodeJS.ErrnoException) => void
    ): void;
    (
        path: string,
        mode: string,
        callback?: (err?: NodeJS.ErrnoException) => void
    ): void;
};

function mkdirSync

mkdirSync: {
    (path: string, mode?: number): void;
    (path: string, mode?: string): void;
    (path: string, mode?: number): void;
    (path: string, mode?: string): void;
};

function open

open: {
    (
        path: string,
        flags: string,
        callback?: (err: NodeJS.ErrnoException, fd: number) => any
    ): void;
    (
        path: string,
        flags: string,
        mode: number,
        callback?: (err: NodeJS.ErrnoException, fd: number) => any
    ): void;
    (
        path: string,
        flags: string,
        mode: string,
        callback?: (err: NodeJS.ErrnoException, fd: number) => any
    ): void;
    (
        path: string,
        flags: string,
        callback?: (err: NodeJS.ErrnoException, fd: number) => any
    ): void;
    (
        path: string,
        flags: string,
        mode: number,
        callback?: (err: NodeJS.ErrnoException, fd: number) => any
    ): void;
    (
        path: string,
        flags: string,
        mode: string,
        callback?: (err: NodeJS.ErrnoException, fd: number) => any
    ): void;
};

function openSync

openSync: {
    (path: string, flags: string, mode?: number): number;
    (path: string, flags: string, mode?: string): number;
    (path: string, flags: string, mode?: number): number;
    (path: string, flags: string, mode?: string): number;
};

function read

read: {
    (
        fd: number,
        buffer: Buffer,
        offset: number,
        length: number,
        position: number,
        callback?: (
            err: NodeJS.ErrnoException,
            bytesRead: number,
            buffer: Buffer
        ) => void
    ): void;
    (
        fd: number,
        buffer: Buffer,
        offset: number,
        length: number,
        position: number,
        callback?: (
            err: NodeJS.ErrnoException,
            bytesRead: number,
            buffer: Buffer
        ) => void
    ): void;
};

function readdir

readdir: {
    (
        path: string,
        callback?: (err: NodeJS.ErrnoException, files: string[]) => void
    ): void;
    (
        path: string,
        callback?: (err: NodeJS.ErrnoException, files: string[]) => void
    ): void;
};

function readdirSync

readdirSync: { (path: string): string[]; (path: string): string[] };

function readFile

readFile: {
    (
        filename: string,
        encoding: string,
        callback: (err: NodeJS.ErrnoException, data: string) => void
    ): void;
    (
        filename: string,
        options: { encoding: string; flag?: string },
        callback: (err: NodeJS.ErrnoException, data: string) => void
    ): void;
    (
        filename: string,
        options: { flag?: string },
        callback: (err: NodeJS.ErrnoException, data: Buffer) => void
    ): void;
    (
        filename: string,
        callback: (err: NodeJS.ErrnoException, data: Buffer) => void
    ): void;
    (
        filename: string,
        encoding: string,
        callback: (err: NodeJS.ErrnoException, data: string) => void
    ): void;
    (
        filename: string,
        options: { encoding: string; flag?: string },
        callback: (err: NodeJS.ErrnoException, data: string) => void
    ): void;
    (
        filename: string,
        options: { flag?: string },
        callback: (err: NodeJS.ErrnoException, data: Buffer) => void
    ): void;
    (
        filename: string,
        callback: (err: NodeJS.ErrnoException, data: Buffer) => void
    ): void;
};

function readFileSync

readFileSync: {
    (filename: string, encoding: string): string;
    (filename: string, options: { encoding: string; flag?: string }): string;
    (filename: string, options?: { flag?: string }): Buffer;
    (filename: string, encoding: string): string;
    (filename: string, options: { encoding: string; flag?: string }): string;
    (filename: string, options?: { flag?: string }): Buffer;
};

function readlink

readlink: {
    (
        path: string,
        callback?: (err: NodeJS.ErrnoException, linkString: string) => any
    ): void;
    (
        path: string,
        callback?: (err: NodeJS.ErrnoException, linkString: string) => any
    ): void;
};

function readlinkSync

readlinkSync: { (path: string): string; (path: string): string };

function readSync

readSync: {
    (
        fd: number,
        buffer: Buffer,
        offset: number,
        length: number,
        position: number
    ): number;
    (
        fd: number,
        buffer: Buffer,
        offset: number,
        length: number,
        position: number
    ): number;
};

function realpath

realpath: {
    (
        path: string,
        callback?: (err: NodeJS.ErrnoException, resolvedPath: string) => any
    ): void;
    (
        path: string,
        cache: { [path: string]: string },
        callback: (err: NodeJS.ErrnoException, resolvedPath: string) => any
    ): void;
    (
        path: string,
        callback?: (err: NodeJS.ErrnoException, resolvedPath: string) => any
    ): void;
    (
        path: string,
        cache: { [path: string]: string },
        callback: (err: NodeJS.ErrnoException, resolvedPath: string) => any
    ): void;
};

function realpathSync

realpathSync: {
    (path: string, cache?: { [path: string]: string }): string;
    (path: string, cache?: { [path: string]: string }): string;
};

function rename

rename: {
    (
        oldPath: string,
        newPath: string,
        callback?: (err?: NodeJS.ErrnoException) => void
    ): void;
    (
        oldPath: string,
        newPath: string,
        callback?: (err?: NodeJS.ErrnoException) => void
    ): void;
};

function renameSync

renameSync: {
    (oldPath: string, newPath: string): void;
    (oldPath: string, newPath: string): void;
};

function rmdir

rmdir: {
    (path: string, callback?: (err?: NodeJS.ErrnoException) => void): void;
    (path: string, callback?: (err?: NodeJS.ErrnoException) => void): void;
};

function rmdirSync

rmdirSync: { (path: string): void; (path: string): void };

function stat

stat: {
    (
        path: string,
        callback?: (err: NodeJS.ErrnoException, stats: Stats) => any
    ): void;
    (
        path: string,
        callback?: (err: NodeJS.ErrnoException, stats: Stats) => any
    ): void;
};

function statSync

statSync: { (path: string): Stats; (path: string): Stats };

function symlink

symlink: {
    (
        srcpath: string,
        dstpath: string,
        type?: string,
        callback?: (err?: NodeJS.ErrnoException) => void
    ): void;
    (
        srcpath: string,
        dstpath: string,
        type?: string,
        callback?: (err?: NodeJS.ErrnoException) => void
    ): void;
};

function symlinkSync

symlinkSync: {
    (srcpath: string, dstpath: string, type?: string): void;
    (srcpath: string, dstpath: string, type?: string): void;
};

function truncate

truncate: {
    (path: string, callback?: (err?: NodeJS.ErrnoException) => void): void;
    (
        path: string,
        len: number,
        callback?: (err?: NodeJS.ErrnoException) => void
    ): void;
    (path: string, callback?: (err?: NodeJS.ErrnoException) => void): void;
    (
        path: string,
        len: number,
        callback?: (err?: NodeJS.ErrnoException) => void
    ): void;
};

function truncateSync

truncateSync: {
    (path: string, len?: number): void;
    (path: string, len?: number): void;
};

function unlink

unlink: {
    (path: string, callback?: (err?: NodeJS.ErrnoException) => void): void;
    (path: string, callback?: (err?: NodeJS.ErrnoException) => void): void;
};

function unlinkSync

unlinkSync: { (path: string): void; (path: string): void };

function unwatchFile

unwatchFile: {
    (filename: string, listener?: (curr: Stats, prev: Stats) => void): void;
    (filename: string, listener?: (curr: Stats, prev: Stats) => void): void;
};

function utimes

utimes: {
    (
        path: string,
        atime: number,
        mtime: number,
        callback?: (err?: NodeJS.ErrnoException) => void
    ): void;
    (
        path: string,
        atime: Date,
        mtime: Date,
        callback?: (err?: NodeJS.ErrnoException) => void
    ): void;
    (
        path: string,
        atime: number,
        mtime: number,
        callback?: (err?: NodeJS.ErrnoException) => void
    ): void;
    (
        path: string,
        atime: Date,
        mtime: Date,
        callback?: (err?: NodeJS.ErrnoException) => void
    ): void;
};

function utimesSync

utimesSync: {
    (path: string, atime: number, mtime: number): void;
    (path: string, atime: Date, mtime: Date): void;
    (path: string, atime: number, mtime: number): void;
    (path: string, atime: Date, mtime: Date): void;
};

function watch

watch: {
    (
        filename: string,
        listener?: (event: string, filename: string) => any
    ): FSWatcher;
    (
        filename: string,
        options: { persistent?: boolean },
        listener?: (event: string, filename: string) => any
    ): FSWatcher;
    (
        filename: string,
        listener?: (event: string, filename: string) => any
    ): FSWatcher;
    (
        filename: string,
        options: { persistent?: boolean },
        listener?: (event: string, filename: string) => any
    ): FSWatcher;
};

function watchFile

watchFile: {
    (filename: string, listener: (curr: Stats, prev: Stats) => void): void;
    (
        filename: string,
        options: { persistent?: boolean; interval?: number },
        listener: (curr: Stats, prev: Stats) => void
    ): void;
    (filename: string, listener: (curr: Stats, prev: Stats) => void): void;
    (
        filename: string,
        options: { persistent?: boolean; interval?: number },
        listener: (curr: Stats, prev: Stats) => void
    ): void;
};

function write

write: {
    (
        fd: number,
        buffer: Buffer,
        offset: number,
        length: number,
        position: number,
        callback?: (
            err: NodeJS.ErrnoException,
            written: number,
            buffer: Buffer
        ) => void
    ): void;
    (
        fd: number,
        buffer: Buffer,
        offset: number,
        length: number,
        position: number,
        callback?: (
            err: NodeJS.ErrnoException,
            written: number,
            buffer: Buffer
        ) => void
    ): void;
};

function writeFile

writeFile: {
    (
        filename: string,
        data: any,
        callback?: (err: NodeJS.ErrnoException) => void
    ): void;
    (
        filename: string,
        data: any,
        options: { encoding?: string; mode?: number; flag?: string },
        callback?: (err: NodeJS.ErrnoException) => void
    ): void;
    (
        filename: string,
        data: any,
        options: { encoding?: string; mode?: string; flag?: string },
        callback?: (err: NodeJS.ErrnoException) => void
    ): void;
    (
        filename: string,
        data: any,
        callback?: (err: NodeJS.ErrnoException) => void
    ): void;
    (
        filename: string,
        data: any,
        options: { encoding?: string; mode?: number; flag?: string },
        callback?: (err: NodeJS.ErrnoException) => void
    ): void;
    (
        filename: string,
        data: any,
        options: { encoding?: string; mode?: string; flag?: string },
        callback?: (err: NodeJS.ErrnoException) => void
    ): void;
};

function writeFileSync

writeFileSync: {
    (
        filename: string,
        data: any,
        options?: { encoding?: string; mode?: number; flag?: string }
    ): void;
    (
        filename: string,
        data: any,
        options?: { encoding?: string; mode?: string; flag?: string }
    ): void;
    (
        filename: string,
        data: any,
        options?: { encoding?: string; mode?: number; flag?: string }
    ): void;
    (
        filename: string,
        data: any,
        options?: { encoding?: string; mode?: string; flag?: string }
    ): void;
};

function writeSync

writeSync: {
    (
        fd: number,
        buffer: Buffer,
        offset: number,
        length: number,
        position: number
    ): number;
    (
        fd: number,
        buffer: Buffer,
        offset: number,
        length: number,
        position: number
    ): number;
};

interface FSWatcher

interface FSWatcher extends events.EventEmitter {}

method close

close: { (): void; (): void };

interface ReadStream

interface ReadStream extends stream.Readable {}

method close

close: { (): void; (): void };

interface Stats

interface Stats {}

property atime

atime: Date;

property blksize

blksize: number;

property blocks

blocks: number;

property ctime

ctime: Date;

property dev

dev: number;

property gid

gid: number;

property ino

ino: number;

property mode

mode: number;

property mtime

mtime: Date;

property nlink

nlink: number;

property rdev

rdev: number;

property size

size: number;

property uid

uid: number;

method isBlockDevice

isBlockDevice: { (): boolean; (): boolean };

method isCharacterDevice

isCharacterDevice: { (): boolean; (): boolean };

method isDirectory

isDirectory: { (): boolean; (): boolean };

method isFIFO

isFIFO: { (): boolean; (): boolean };

method isFile

isFile: { (): boolean; (): boolean };

method isSocket

isSocket: { (): boolean; (): boolean };

method isSymbolicLink

isSymbolicLink: { (): boolean; (): boolean };

interface WriteStream

interface WriteStream extends stream.Writable {}

method close

close: { (): void; (): void };

namespace gulp-util

module 'gulp-util' {}

variable colors

var colors: Chalk.ChalkModule;

variable date

var date: {
    (now?: Date, mask?: string, convertLocalTimeToUTC?: boolean): any;
    (date?: string, mask?: string, convertLocalTimeToUTC?: boolean): any;
    masks: any;
};

variable env

var env: any;

variable linefeed

var linefeed: string;

variable noop

var noop: typeof through2;

Returns a stream that does nothing but pass data straight through.

function beep

beep: { (): void; (): void };

function buffer

buffer: {
    (cb?: (err: Error, data: any[]) => void): NodeJS.ReadWriteStream;
    (cb?: (err: Error, data: any[]) => void): NodeJS.ReadWriteStream;
};

This is similar to es.wait but instead of buffering text into one string it buffers anything into an array (so very useful for file objects).

function combine

combine: {
    (streams: NodeJS.ReadWriteStream[]): () => NodeJS.ReadWriteStream;
    (...streams: NodeJS.ReadWriteStream[]): () => NodeJS.ReadWriteStream;
    (streams: NodeJS.ReadWriteStream[]): () => NodeJS.ReadWriteStream;
    (...streams: NodeJS.ReadWriteStream[]): () => NodeJS.ReadWriteStream;
};

function isBuffer

isBuffer: { (obj: any): boolean; (obj: any): boolean };

function isNull

isNull: { (obj: any): boolean; (obj: any): boolean };

function isStream

isStream: { (obj: any): boolean; (obj: any): boolean };

function log

log: {
    (message?: any, ...optionalParams: any[]): void;
    (message?: any, ...optionalParams: any[]): void;
};

Logs stuff. Already prefixed with [gulp] and all that. Use the right colors for values. If you pass in multiple arguments it will join them by a space.

function replaceExtension

replaceExtension: {
    (npath: string, ext: string): string;
    (npath: string, ext: string): string;
};

Replaces a file extension in a path. Returns the new path.

function template

template: {
    (tmpl: string): (opt: { file: { path: string } }) => string;
    (tmpl: string, opt: { file: { path: string } }): string;
    (tmpl: string): (opt: { file: { path: string } }) => string;
    (tmpl: string, opt: { file: { path: string } }): string;
};

This is a lodash.template function wrapper. You must pass in a valid gulp file object so it is available to the user or it will error. You can not configure any of the delimiters. Look at the lodash docs for more info.

class File

class File extends vinyl {}

class PluginError

class PluginError implements Error, PluginErrorOptions {}

constructor

constructor(options?: PluginErrorOptions);

constructor

constructor(pluginName: string, options?: PluginErrorOptions);

constructor

constructor(pluginName: string, message: string, options?: PluginErrorOptions);

constructor

constructor(pluginName: string, message: Error, options?: PluginErrorOptions);

property error

error: Error;

property fileName

fileName: string;

property lineNumber

lineNumber: number;

property message

message: any;

Can be a string or an existing error.

property name

name: string;

The module name of your plugin.

property plugin

plugin: string;

property showProperties

showProperties: boolean;

Error properties will be included in err.toString(). Can be omitted by setting this to false.

property showStack

showStack: boolean;

By default the stack will not be shown. Set this to true if you think the stack is important for your error.

property stack

stack: string;

You need to include the message along with this stack. If you pass an error in as the message the stack will be pulled from that, otherwise one will be created.

namespace http

module 'http' {}

variable globalAgent

var globalAgent: Agent;

variable STATUS_CODES

var STATUS_CODES: { [errorCode: number]: string; [errorCode: string]: string };

function createClient

createClient: {
    (port?: number, host?: string): any;
    (port?: number, host?: string): any;
};

function createServer

createServer: {
    (
        requestListener?: (
            request: IncomingMessage,
            response: ServerResponse
        ) => void
    ): Server;
    (
        requestListener?: (
            request: IncomingMessage,
            response: ServerResponse
        ) => void
    ): Server;
};

function get

get: {
    (options: any, callback?: (res: IncomingMessage) => void): ClientRequest;
    (options: any, callback?: (res: IncomingMessage) => void): ClientRequest;
};

function request

request: {
    (options: any, callback?: (res: IncomingMessage) => void): ClientRequest;
    (options: any, callback?: (res: IncomingMessage) => void): ClientRequest;
};

class Agent

class Agent {}

constructor

constructor(opts?: AgentOptions);

property maxSockets

maxSockets: number;

property requests

requests: any;

property sockets

sockets: any;

method destroy

destroy: () => void;

Destroy any sockets that are currently in use by the agent. It is usually not necessary to do this. However, if you are using an agent with KeepAlive enabled, then it is best to explicitly shut down the agent when you know that it will no longer be used. Otherwise, sockets may hang open for quite a long time before the server terminates them.

interface AgentOptions

interface AgentOptions {}

property keepAlive

keepAlive?: boolean;

Keep sockets around in a pool to be used by other requests in the future. Default = false

property keepAliveMsecs

keepAliveMsecs?: number;

When using HTTP KeepAlive, how often to send TCP KeepAlive packets over sockets being kept alive. Default = 1000. Only relevant if keepAlive is set to true.

property maxFreeSockets

maxFreeSockets?: number;

Maximum number of sockets to leave open in a free state. Only relevant if keepAlive is set to true. Default = 256.

property maxSockets

maxSockets?: number;

Maximum number of sockets to allow per host. Default for Node 0.10 is 5, default for Node 0.12 is Infinity

interface ClientRequest

interface ClientRequest extends events.EventEmitter, stream.Writable {}

method abort

abort: { (): void; (): void };

method end

end: {
    (): void;
    (buffer: Buffer, cb?: Function): void;
    (str: string, cb?: Function): void;
    (str: string, encoding?: string, cb?: Function): void;
    (data?: any, encoding?: string): void;
    (): void;
    (buffer: Buffer, cb?: Function): void;
    (str: string, cb?: Function): void;
    (str: string, encoding?: string, cb?: Function): void;
    (data?: any, encoding?: string): void;
};

method setNoDelay

setNoDelay: { (noDelay?: boolean): void; (noDelay?: boolean): void };

method setSocketKeepAlive

setSocketKeepAlive: {
    (enable?: boolean, initialDelay?: number): void;
    (enable?: boolean, initialDelay?: number): void;
};

method setTimeout

setTimeout: {
    (timeout: number, callback?: Function): void;
    (timeout: number, callback?: Function): void;
};

method write

write: {
    (buffer: Buffer): boolean;
    (buffer: Buffer, cb?: Function): boolean;
    (str: string, cb?: Function): boolean;
    (str: string, encoding?: string, cb?: Function): boolean;
    (str: string, encoding?: string, fd?: string): boolean;
    (chunk: any, encoding?: string): void;
    (buffer: Buffer): boolean;
    (buffer: Buffer, cb?: Function): boolean;
    (str: string, cb?: Function): boolean;
    (str: string, encoding?: string, cb?: Function): boolean;
    (str: string, encoding?: string, fd?: string): boolean;
    (chunk: any, encoding?: string): void;
};

interface ClientResponse

interface ClientResponse extends IncomingMessage {}

Deprecated
Use IncomingMessage

interface IncomingMessage

interface IncomingMessage extends events.EventEmitter, stream.Readable {}

property headers

headers: any;

property httpVersion

httpVersion: string;

property method

method?: string;

Only valid for request obtained from http.Server.

property rawHeaders

rawHeaders: string[];

property rawTrailers

rawTrailers: any;

property socket

socket: net.Socket;

property statusCode

statusCode?: number;

Only valid for response obtained from http.ClientRequest.

property statusMessage

statusMessage?: string;

Only valid for response obtained from http.ClientRequest.

property trailers

trailers: any;

property url

url?: string;

Only valid for request obtained from http.Server.

method setTimeout

setTimeout: {
    (msecs: number, callback: Function): NodeJS.Timer;
    (msecs: number, callback: Function): NodeJS.Timer;
};

interface Server

interface Server extends events.EventEmitter {}

property maxHeadersCount

maxHeadersCount: number;

method address

address: {
    (): { port: number; family: string; address: string };
    (): { port: number; family: string; address: string };
};

method close

close: { (cb?: any): Server; (cb?: any): Server };

method listen

listen: {
    (
        port: number,
        hostname?: string,
        backlog?: number,
        callback?: Function
    ): Server;
    (path: string, callback?: Function): Server;
    (handle: any, listeningListener?: Function): Server;
    (
        port: number,
        hostname?: string,
        backlog?: number,
        callback?: Function
    ): Server;
    (path: string, callback?: Function): Server;
    (handle: any, listeningListener?: Function): Server;
};

interface ServerRequest

interface ServerRequest extends IncomingMessage {}

Deprecated
Use IncomingMessage

property connection

connection: net.Socket;

interface ServerResponse

interface ServerResponse extends events.EventEmitter, stream.Writable {}

property sendDate

sendDate: boolean;

property statusCode

statusCode: number;

method addTrailers

addTrailers: { (headers: any): void; (headers: any): void };

method end

end: {
    (): void;
    (buffer: Buffer, cb?: Function): void;
    (str: string, cb?: Function): void;
    (str: string, encoding?: string, cb?: Function): void;
    (data?: any, encoding?: string): void;
    (): void;
    (buffer: Buffer, cb?: Function): void;
    (str: string, cb?: Function): void;
    (str: string, encoding?: string, cb?: Function): void;
    (data?: any, encoding?: string): void;
};

method getHeader

getHeader: { (name: string): string; (name: string): string };

method removeHeader

removeHeader: { (name: string): void; (name: string): void };

method setHeader

setHeader: {
    (name: string, value: string): void;
    (name: string, value: string): void;
};

method write

write: {
    (buffer: Buffer): boolean;
    (buffer: Buffer, cb?: Function): boolean;
    (str: string, cb?: Function): boolean;
    (str: string, encoding?: string, cb?: Function): boolean;
    (str: string, encoding?: string, fd?: string): boolean;
    (chunk: any, encoding?: string): any;
    (buffer: Buffer): boolean;
    (buffer: Buffer, cb?: Function): boolean;
    (str: string, cb?: Function): boolean;
    (str: string, encoding?: string, cb?: Function): boolean;
    (str: string, encoding?: string, fd?: string): boolean;
    (chunk: any, encoding?: string): any;
};

method writeContinue

writeContinue: { (): void; (): void };

method writeHead

writeHead: {
    (statusCode: number, reasonPhrase?: string, headers?: any): void;
    (statusCode: number, headers?: any): void;
    (statusCode: number, reasonPhrase?: string, headers?: any): void;
    (statusCode: number, headers?: any): void;
};

namespace https

module 'https' {}

variable Agent

var Agent: new (options?: RequestOptions) => Agent;

variable globalAgent

var globalAgent: Agent;

function createServer

createServer: {
    (options: ServerOptions, requestListener?: Function): Server;
    (options: ServerOptions, requestListener?: Function): Server;
};

function get

get: {
    (
        options: RequestOptions,
        callback?: (res: http.IncomingMessage) => void
    ): http.ClientRequest;
    (
        options: RequestOptions,
        callback?: (res: http.IncomingMessage) => void
    ): http.ClientRequest;
};

function request

request: {
    (
        options: RequestOptions,
        callback?: (res: http.IncomingMessage) => void
    ): http.ClientRequest;
    (
        options: RequestOptions,
        callback?: (res: http.IncomingMessage) => void
    ): http.ClientRequest;
};

interface Agent

interface Agent {}

property maxSockets

maxSockets: number;

property requests

requests: any;

property sockets

sockets: any;

interface RequestOptions

interface RequestOptions {}

property agent

agent?: any;

property auth

auth?: string;

property ca

ca?: any;

property cert

cert?: any;

property ciphers

ciphers?: string;

property headers

headers?: any;

property host

host?: string;

property hostname

hostname?: string;

property key

key?: any;

property method

method?: string;

property passphrase

passphrase?: string;

property path

path?: string;

property pfx

pfx?: any;

property port

port?: number;

property rejectUnauthorized

rejectUnauthorized?: boolean;

interface Server

interface Server extends tls.Server {}

interface ServerOptions

interface ServerOptions {}

property ca

ca?: any;

property cert

cert?: any;

property ciphers

ciphers?: string;

property crl

crl?: any;

property honorCipherOrder

honorCipherOrder?: boolean;

property key

key?: any;

property NPNProtocols

NPNProtocols?: any;

property passphrase

passphrase?: string;

property pfx

pfx?: any;

property rejectUnauthorized

rejectUnauthorized?: boolean;

property requestCert

requestCert?: boolean;

property SNICallback

SNICallback?: (servername: string) => any;

namespace mocha

module 'mocha' {}

class Mocha

class Mocha {}

constructor

constructor(options?: {
    grep?: RegExp;
    ui?: string;
    reporter?: string;
    timeout?: number;
    bail?: boolean;
});

method addFile

addFile: (file: string) => Mocha;

method asyncOnly

asyncOnly: (value: boolean) => Mocha;

method bail

bail: (value?: boolean) => Mocha;

method checkLeaks

checkLeaks: () => Mocha;

method enableTimeouts

enableTimeouts: (value: boolean) => Mocha;

method globals

globals: { (value: string): Mocha; (values: string[]): Mocha };

method grep

grep: { (value: string): Mocha; (value: RegExp): Mocha };

method growl

growl: () => Mocha;

method ignoreLeaks

ignoreLeaks: (value: boolean) => Mocha;

method invert

invert: () => Mocha;

method noHighlighting

noHighlighting: (value: boolean) => Mocha;

method reporter

reporter: (value: string) => Mocha;

method run

run: (onComplete?: (failures: number) => void) => void;

method slow

slow: (value: number) => Mocha;

method timeout

timeout: (value: number) => Mocha;

method ui

ui: (value: string) => Mocha;

method useColors

useColors: (value: boolean) => Mocha;

method useInlineDiffs

useInlineDiffs: (value: boolean) => Mocha;

namespace net

module 'net' {}

variable Socket

var Socket: new (options?: {
    fd?: string;
    type?: string;
    allowHalfOpen?: boolean;
}) => Socket;

function connect

connect: {
    (options: { allowHalfOpen?: boolean }, connectionListener?: Function): Socket;
    (port: number, host?: string, connectionListener?: Function): Socket;
    (path: string, connectionListener?: Function): Socket;
    (options: { allowHalfOpen?: boolean }, connectionListener?: Function): Socket;
    (port: number, host?: string, connectionListener?: Function): Socket;
    (path: string, connectionListener?: Function): Socket;
};

function createConnection

createConnection: {
    (options: { allowHalfOpen?: boolean }, connectionListener?: Function): Socket;
    (port: number, host?: string, connectionListener?: Function): Socket;
    (path: string, connectionListener?: Function): Socket;
    (options: { allowHalfOpen?: boolean }, connectionListener?: Function): Socket;
    (port: number, host?: string, connectionListener?: Function): Socket;
    (path: string, connectionListener?: Function): Socket;
};

function createServer

createServer: {
    (connectionListener?: (socket: Socket) => void): Server;
    (
        options?: { allowHalfOpen?: boolean },
        connectionListener?: (socket: Socket) => void
    ): Server;
    (connectionListener?: (socket: Socket) => void): Server;
    (
        options?: { allowHalfOpen?: boolean },
        connectionListener?: (socket: Socket) => void
    ): Server;
};

function isIP

isIP: { (input: string): number; (input: string): number };

function isIPv4

isIPv4: { (input: string): boolean; (input: string): boolean };

function isIPv6

isIPv6: { (input: string): boolean; (input: string): boolean };

interface Server

interface Server extends Socket {}

property connections

connections: number;

property maxConnections

maxConnections: number;

method address

address: {
    (): { port: number; family: string; address: string };
    (): { port: number; family: string; address: string };
};

method close

close: { (callback?: Function): Server; (callback?: Function): Server };

method listen

listen: {
    (
        port: number,
        host?: string,
        backlog?: number,
        listeningListener?: Function
    ): Server;
    (path: string, listeningListener?: Function): Server;
    (handle: any, listeningListener?: Function): Server;
    (
        port: number,
        host?: string,
        backlog?: number,
        listeningListener?: Function
    ): Server;
    (path: string, listeningListener?: Function): Server;
    (handle: any, listeningListener?: Function): Server;
};

interface Socket

interface Socket extends stream.Duplex {}

property bufferSize

bufferSize: number;

property bytesRead

bytesRead: number;

property bytesWritten

bytesWritten: number;

property localAddress

localAddress: string;

property localPort

localPort: number;

property remoteAddress

remoteAddress: string;

property remoteFamily

remoteFamily: string;

property remotePort

remotePort: number;

method address

address: {
    (): { port: number; family: string; address: string };
    (): { port: number; family: string; address: string };
};

method connect

connect: {
    (port: number, host?: string, connectionListener?: Function): void;
    (path: string, connectionListener?: Function): void;
    (port: number, host?: string, connectionListener?: Function): void;
    (path: string, connectionListener?: Function): void;
};

method destroy

destroy: { (): void; (): void };

method end

end: {
    (): void;
    (buffer: Buffer, cb?: Function): void;
    (str: string, cb?: Function): void;
    (str: string, encoding?: string, cb?: Function): void;
    (data?: any, encoding?: string): void;
    (): void;
    (buffer: Buffer, cb?: Function): void;
    (str: string, cb?: Function): void;
    (str: string, encoding?: string, cb?: Function): void;
    (data?: any, encoding?: string): void;
};

method pause

pause: { (): void; (): void };

method ref

ref: { (): void; (): void };

method resume

resume: { (): void; (): void };

method setEncoding

setEncoding: { (encoding?: string): void; (encoding?: string): void };

method setKeepAlive

setKeepAlive: {
    (enable?: boolean, initialDelay?: number): void;
    (enable?: boolean, initialDelay?: number): void;
};

method setNoDelay

setNoDelay: { (noDelay?: boolean): void; (noDelay?: boolean): void };

method setTimeout

setTimeout: {
    (timeout: number, callback?: Function): void;
    (timeout: number, callback?: Function): void;
};

method unref

unref: { (): void; (): void };

method write

write: {
    (buffer: Buffer): boolean;
    (buffer: Buffer, cb?: Function): boolean;
    (str: string, cb?: Function): boolean;
    (str: string, encoding?: string, cb?: Function): boolean;
    (str: string, encoding?: string, fd?: string): boolean;
    (data: any, encoding?: string, callback?: Function): void;
    (buffer: Buffer): boolean;
    (buffer: Buffer, cb?: Function): boolean;
    (str: string, cb?: Function): boolean;
    (str: string, encoding?: string, cb?: Function): boolean;
    (str: string, encoding?: string, fd?: string): boolean;
    (data: any, encoding?: string, callback?: Function): void;
};

namespace os

module 'os' {}

variable EOL

var EOL: string;

function arch

arch: { (): string; (): string };

function cpus

cpus: {
    (): {
        model: string;
        speed: number;
        times: {
            user: number;
            nice: number;
            sys: number;
            idle: number;
            irq: number;
        };
    }[];
    (): {
        model: string;
        speed: number;
        times: {
            user: number;
            nice: number;
            sys: number;
            idle: number;
            irq: number;
        };
    }[];
};

function freemem

freemem: { (): number; (): number };

function hostname

hostname: { (): string; (): string };

function loadavg

loadavg: { (): number[]; (): number[] };

function networkInterfaces

networkInterfaces: { (): any; (): any };

function platform

platform: { (): string; (): string };

function release

release: { (): string; (): string };

function tmpdir

tmpdir: { (): string; (): string };

function totalmem

totalmem: { (): number; (): number };

function type

type: { (): string; (): string };

function uptime

uptime: { (): number; (): number };

namespace path

module 'path' {}

variable delimiter

var delimiter: string;

variable sep

var sep: string;

function basename

basename: {
    (p: string, ext?: string): string;
    (p: string, ext?: string): string;
};

function dirname

dirname: { (p: string): string; (p: string): string };

function extname

extname: { (p: string): string; (p: string): string };

function format

format: { (pP: ParsedPath): string; (pP: ParsedPath): string };

function isAbsolute

isAbsolute: { (p: string): boolean; (p: string): boolean };

function join

join: { (...paths: any[]): string; (...paths: any[]): string };

function normalize

normalize: { (p: string): string; (p: string): string };

function parse

parse: { (p: string): ParsedPath; (p: string): ParsedPath };

function relative

relative: {
    (from: string, to: string): string;
    (from: string, to: string): string;
};

function resolve

resolve: { (...pathSegments: any[]): string; (...pathSegments: any[]): string };

interface ParsedPath

interface ParsedPath {}

property base

base: string;

property dir

dir: string;

property ext

ext: string;

property name

name: string;

property root

root: string;

namespace path.posix

namespace path.posix {}

variable delimiter

var delimiter: string;

variable sep

var sep: string;

function basename

basename: {
    (p: string, ext?: string): string;
    (p: string, ext?: string): string;
};

function dirname

dirname: { (p: string): string; (p: string): string };

function extname

extname: { (p: string): string; (p: string): string };

function format

format: { (pP: ParsedPath): string; (pP: ParsedPath): string };

function isAbsolute

isAbsolute: { (p: string): boolean; (p: string): boolean };

function join

join: { (...paths: any[]): string; (...paths: any[]): string };

function normalize

normalize: { (p: string): string; (p: string): string };

function parse

parse: { (p: string): ParsedPath; (p: string): ParsedPath };

function relative

relative: {
    (from: string, to: string): string;
    (from: string, to: string): string;
};

function resolve

resolve: { (...pathSegments: any[]): string; (...pathSegments: any[]): string };

namespace path.win32

namespace path.win32 {}

variable delimiter

var delimiter: string;

variable sep

var sep: string;

function basename

basename: {
    (p: string, ext?: string): string;
    (p: string, ext?: string): string;
};

function dirname

dirname: { (p: string): string; (p: string): string };

function extname

extname: { (p: string): string; (p: string): string };

function format

format: { (pP: ParsedPath): string; (pP: ParsedPath): string };

function isAbsolute

isAbsolute: { (p: string): boolean; (p: string): boolean };

function join

join: { (...paths: any[]): string; (...paths: any[]): string };

function normalize

normalize: { (p: string): string; (p: string): string };

function parse

parse: { (p: string): ParsedPath; (p: string): ParsedPath };

function relative

relative: {
    (from: string, to: string): string;
    (from: string, to: string): string;
};

function resolve

resolve: { (...pathSegments: any[]): string; (...pathSegments: any[]): string };

namespace punycode

module 'punycode' {}

variable ucs2

var ucs2: ucs2;

variable version

var version: any;

function decode

decode: { (string: string): string; (string: string): string };

function encode

encode: { (string: string): string; (string: string): string };

function toASCII

toASCII: { (domain: string): string; (domain: string): string };

function toUnicode

toUnicode: { (domain: string): string; (domain: string): string };

interface ucs2

interface ucs2 {}

method decode

decode: { (string: string): string; (string: string): string };

method encode

encode: { (codePoints: number[]): string; (codePoints: number[]): string };

namespace querystring

module 'querystring' {}

function escape

escape: { (str: string): string; (str: string): string };

function parse

parse: {
    (str: string, sep?: string, eq?: string, options?: { maxKeys?: number }): any;
    (str: string, sep?: string, eq?: string, options?: { maxKeys?: number }): any;
};

function stringify

stringify: {
    (obj: any, sep?: string, eq?: string): string;
    (obj: any, sep?: string, eq?: string): string;
};

function unescape

unescape: { (str: string): string; (str: string): string };

namespace readline

module 'readline' {}

function createInterface

createInterface: {
    (options: ReadLineOptions): ReadLine;
    (options: ReadLineOptions): ReadLine;
};

interface ReadLine

interface ReadLine extends events.EventEmitter {}

method close

close: { (): void; (): void };

method pause

pause: { (): void; (): void };

method prompt

prompt: { (preserveCursor?: boolean): void; (preserveCursor?: boolean): void };

method question

question: {
    (query: string, callback: Function): void;
    (query: string, callback: Function): void;
};

method resume

resume: { (): void; (): void };

method setPrompt

setPrompt: {
    (prompt: string, length: number): void;
    (prompt: string, length: number): void;
};

method write

write: { (data: any, key?: any): void; (data: any, key?: any): void };

interface ReadLineOptions

interface ReadLineOptions {}

property completer

completer?: Function;

property input

input: NodeJS.ReadableStream;

property output

output: NodeJS.WritableStream;

property terminal

terminal?: boolean;

namespace repl

module 'repl' {}

function start

start: {
    (options: ReplOptions): events.EventEmitter;
    (options: ReplOptions): events.EventEmitter;
};

interface ReplOptions

interface ReplOptions {}

property eval

eval?: Function;

property ignoreUndefined

ignoreUndefined?: boolean;

property input

input?: NodeJS.ReadableStream;

property output

output?: NodeJS.WritableStream;

property prompt

prompt?: string;

property terminal

terminal?: boolean;

property useColors

useColors?: boolean;

property useGlobal

useGlobal?: boolean;

property writer

writer?: Function;

namespace stream

module 'stream' {}

class Duplex

class Duplex extends Readable implements NodeJS.ReadWriteStream {}

constructor

constructor(opts?: DuplexOptions);

property writable

writable: boolean;

method end

end: {
    (): void;
    (buffer: Buffer, cb?: Function): void;
    (str: string, cb?: Function): void;
    (str: string, encoding?: string, cb?: Function): void;
};

method write

write: {
    (buffer: Buffer, cb?: Function): boolean;
    (str: string, cb?: Function): boolean;
    (str: string, encoding?: string, cb?: Function): boolean;
};

class PassThrough

class PassThrough extends Transform {}

class Readable

class Readable extends events.EventEmitter implements NodeJS.ReadableStream {}

constructor

constructor(opts?: ReadableOptions);

property readable

readable: boolean;

method pause

pause: () => void;

method pipe

pipe: <T extends NodeJS.WritableStream>(
    destination: T,
    options?: { end?: boolean }
) => T;

method push

push: (chunk: any, encoding?: string) => boolean;

method read

read: (size?: number) => string | Buffer;

method resume

resume: () => void;

method setEncoding

setEncoding: (encoding: string) => void;

method unpipe

unpipe: <T extends NodeJS.WritableStream>(destination?: T) => void;

method unshift

unshift: { (chunk: string): void; (chunk: Buffer): void };

method wrap

wrap: (oldStream: NodeJS.ReadableStream) => NodeJS.ReadableStream;

class Transform

class Transform extends events.EventEmitter implements NodeJS.ReadWriteStream {}

constructor

constructor(opts?: TransformOptions);

property readable

readable: boolean;

property writable

writable: boolean;

method end

end: {
    (): void;
    (buffer: Buffer, cb?: Function): void;
    (str: string, cb?: Function): void;
    (str: string, encoding?: string, cb?: Function): void;
};

method pause

pause: () => void;

method pipe

pipe: <T extends NodeJS.WritableStream>(
    destination: T,
    options?: { end?: boolean }
) => T;

method push

push: (chunk: any, encoding?: string) => boolean;

method read

read: (size?: number) => any;

method resume

resume: () => void;

method setEncoding

setEncoding: (encoding: string) => void;

method unpipe

unpipe: <T extends NodeJS.WritableStream>(destination?: T) => void;

method unshift

unshift: { (chunk: string): void; (chunk: Buffer): void };

method wrap

wrap: (oldStream: NodeJS.ReadableStream) => NodeJS.ReadableStream;

method write

write: {
    (buffer: Buffer, cb?: Function): boolean;
    (str: string, cb?: Function): boolean;
    (str: string, encoding?: string, cb?: Function): boolean;
};

class Writable

class Writable extends events.EventEmitter implements NodeJS.WritableStream {}

constructor

constructor(opts?: WritableOptions);

property writable

writable: boolean;

method end

end: {
    (): void;
    (buffer: Buffer, cb?: Function): void;
    (str: string, cb?: Function): void;
    (str: string, encoding?: string, cb?: Function): void;
};

method write

write: {
    (buffer: Buffer, cb?: Function): boolean;
    (str: string, cb?: Function): boolean;
    (str: string, encoding?: string, cb?: Function): boolean;
};

interface DuplexOptions

interface DuplexOptions extends ReadableOptions, WritableOptions {}

property allowHalfOpen

allowHalfOpen?: boolean;

interface ReadableOptions

interface ReadableOptions {}

property encoding

encoding?: string;

property highWaterMark

highWaterMark?: number;

property objectMode

objectMode?: boolean;

interface Stream

interface Stream extends events.EventEmitter {}

method pipe

pipe: {
    <T extends NodeJS.WritableStream>(
        destination: T,
        options?: { end?: boolean }
    ): T;
    <T extends NodeJS.WritableStream>(
        destination: T,
        options?: { end?: boolean }
    ): T;
};

interface TransformOptions

interface TransformOptions extends ReadableOptions, WritableOptions {}

interface WritableOptions

interface WritableOptions {}

property decodeStrings

decodeStrings?: boolean;

property highWaterMark

highWaterMark?: number;

namespace string_decoder

module 'string_decoder' {}

variable StringDecoder

var StringDecoder: new (encoding: string) => NodeStringDecoder;

interface NodeStringDecoder

interface NodeStringDecoder {}

method detectIncompleteChar

detectIncompleteChar: { (buffer: Buffer): number; (buffer: Buffer): number };

method write

write: { (buffer: Buffer): string; (buffer: Buffer): string };

namespace through2

module 'through2' {}

function obj

obj: (
    transform?: (chunk: any, enc: string, callback: () => void) => void,
    flush?: () => void
) => NodeJS.ReadWriteStream;

function push

push: (data: any) => void;

function through2

through2: typeof through2;

namespace tls

module 'tls' {}

variable CLIENT_RENEG_LIMIT

var CLIENT_RENEG_LIMIT: number;

variable CLIENT_RENEG_WINDOW

var CLIENT_RENEG_WINDOW: number;

function connect

connect: {
    (options: TlsOptions, secureConnectionListener?: () => void): ClearTextStream;
    (
        port: number,
        host?: string,
        options?: ConnectionOptions,
        secureConnectListener?: () => void
    ): ClearTextStream;
    (
        port: number,
        options?: ConnectionOptions,
        secureConnectListener?: () => void
    ): ClearTextStream;
    (options: TlsOptions, secureConnectionListener?: () => void): ClearTextStream;
    (
        port: number,
        host?: string,
        options?: ConnectionOptions,
        secureConnectListener?: () => void
    ): ClearTextStream;
    (
        port: number,
        options?: ConnectionOptions,
        secureConnectListener?: () => void
    ): ClearTextStream;
};

function createSecurePair

createSecurePair: {
    (
        credentials?: crypto.Credentials,
        isServer?: boolean,
        requestCert?: boolean,
        rejectUnauthorized?: boolean
    ): SecurePair;
    (
        credentials?: crypto.Credentials,
        isServer?: boolean,
        requestCert?: boolean,
        rejectUnauthorized?: boolean
    ): SecurePair;
};

function createServer

createServer: {
    (
        options: TlsOptions,
        secureConnectionListener?: (cleartextStream: ClearTextStream) => void
    ): Server;
    (
        options: TlsOptions,
        secureConnectionListener?: (cleartextStream: ClearTextStream) => void
    ): Server;
};

interface ClearTextStream

interface ClearTextStream extends stream.Duplex {}

property address

address: {
    port: number;
    family: string;
    address: string;
};

property authorizationError

authorizationError: Error;

property authorized

authorized: boolean;

property getCipher

getCipher: {
    name: string;
    version: string;
};

property remoteAddress

remoteAddress: string;

property remotePort

remotePort: number;

method getPeerCertificate

getPeerCertificate: { (): any; (): any };

interface ConnectionOptions

interface ConnectionOptions {}

property ca

ca?: any;

property cert

cert?: any;

property host

host?: string;

property key

key?: any;

property NPNProtocols

NPNProtocols?: any;

property passphrase

passphrase?: string;

property pfx

pfx?: any;

property port

port?: number;

property rejectUnauthorized

rejectUnauthorized?: boolean;

property servername

servername?: string;

property socket

socket?: net.Socket;

interface SecurePair

interface SecurePair {}

property cleartext

cleartext: any;

property encrypted

encrypted: any;

interface Server

interface Server extends net.Server {}

property connections

connections: number;

property maxConnections

maxConnections: number;

method addContext

addContext: {
    (
        hostName: string,
        credentials: { key: string; cert: string; ca: string }
    ): void;
    (
        hostName: string,
        credentials: { key: string; cert: string; ca: string }
    ): void;
};

method address

address: {
    (): { port: number; family: string; address: string };
    (): { port: number; family: string; address: string };
};

method close

close: { (): Server; (): Server };

method listen

listen: {
    (
        port: number,
        host?: string,
        backlog?: number,
        listeningListener?: Function
    ): Server;
    (path: string, listeningListener?: Function): Server;
    (handle: any, listeningListener?: Function): Server;
    (port: number, host?: string, callback?: Function): Server;
    (
        port: number,
        host?: string,
        backlog?: number,
        listeningListener?: Function
    ): Server;
    (path: string, listeningListener?: Function): Server;
    (handle: any, listeningListener?: Function): Server;
    (port: number, host?: string, callback?: Function): Server;
};

interface TlsOptions

interface TlsOptions {}

property ca

ca?: any;

property cert

cert?: any;

property ciphers

ciphers?: string;

property crl

crl?: any;

property honorCipherOrder

honorCipherOrder?: any;

property key

key?: any;

property NPNProtocols

NPNProtocols?: any;

property passphrase

passphrase?: string;

property pfx

pfx?: any;

property rejectUnauthorized

rejectUnauthorized?: boolean;

property requestCert

requestCert?: boolean;

property SNICallback

SNICallback?: (servername: string) => any;

namespace tty

module 'tty' {}

function isatty

isatty: { (fd: number): boolean; (fd: number): boolean };

interface ReadStream

interface ReadStream extends net.Socket {}

property isRaw

isRaw: boolean;

method setRawMode

setRawMode: { (mode: boolean): void; (mode: boolean): void };

interface WriteStream

interface WriteStream extends net.Socket {}

property columns

columns: number;

property rows

rows: number;

namespace url

module 'url' {}

function format

format: { (url: UrlOptions): string; (url: UrlOptions): string };

function parse

parse: {
    (urlStr: string, parseQueryString?: boolean, slashesDenoteHost?: boolean): Url;
    (urlStr: string, parseQueryString?: boolean, slashesDenoteHost?: boolean): Url;
};

function resolve

resolve: {
    (from: string, to: string): string;
    (from: string, to: string): string;
};

interface Url

interface Url {}

property auth

auth: string;

property hash

hash?: string;

property host

host: string;

property hostname

hostname: string;

property href

href: string;

property path

path?: string;

property pathname

pathname: string;

property port

port: string;

property protocol

protocol: string;

property query

query: any;

property search

search: string;

property slashes

slashes: boolean;

interface UrlOptions

interface UrlOptions {}

property auth

auth?: string;

property hash

hash?: string;

property host

host?: string;

property hostname

hostname?: string;

property path

path?: string;

property pathname

pathname?: string;

property port

port?: string;

property protocol

protocol?: string;

property query

query?: any;

property search

search?: string;

namespace util

module 'util' {}

function debug

debug: { (string: string): void; (string: string): void };

function error

error: { (...param: any[]): void; (...param: any[]): void };

function format

format: {
    (format: any, ...param: any[]): string;
    (format: any, ...param: any[]): string;
};

function inherits

inherits: {
    (constructor: any, superConstructor: any): void;
    (constructor: any, superConstructor: any): void;
};

function inspect

inspect: {
    (object: any, showHidden?: boolean, depth?: number, color?: boolean): string;
    (object: any, options: InspectOptions): string;
    (object: any, showHidden?: boolean, depth?: number, color?: boolean): string;
    (object: any, options: InspectOptions): string;
};

function isArray

isArray: { (object: any): boolean; (object: any): boolean };

function isDate

isDate: { (object: any): boolean; (object: any): boolean };

function isError

isError: { (object: any): boolean; (object: any): boolean };

function isRegExp

isRegExp: { (object: any): boolean; (object: any): boolean };

function log

log: { (string: string): void; (string: string): void };

function print

print: { (...param: any[]): void; (...param: any[]): void };

function puts

puts: { (...param: any[]): void; (...param: any[]): void };

interface InspectOptions

interface InspectOptions {}

property colors

colors?: boolean;

property customInspect

customInspect?: boolean;

property depth

depth?: number;

property showHidden

showHidden?: boolean;

namespace vinyl

module 'vinyl' {}

class File

class File {}

A virtual file format.

constructor

constructor(options?: {
    cwd?: string;
    base?: string;
    path?: string;
    contents?: any;
});

property base

base: string;

Used for relative pathing. Typically where a glob starts.

property contents

contents: any;

Type: Buffer|Stream|null (Default: null)

property cwd

cwd: string;

Default: process.cwd()

property path

path: string;

Full path to the file.

property relative

relative: string;

Returns path.relative for the file base and file path. Example: var file = new File({ cwd: "/", base: "/test/", path: "/test/file.js" }); console.log(file.relative); // file.js

property stat

stat: fs.Stats;

method clone

clone: (opts?: { contents?: boolean }) => File;

Returns a new File object with all attributes cloned. Custom attributes are deep-cloned.

method inspect

inspect: () => string;

Returns a pretty String interpretation of the File. Useful for console.log.

method isBuffer

isBuffer: () => boolean;

method isDirectory

isDirectory: () => boolean;

method isNull

isNull: () => boolean;

method isStream

isStream: () => boolean;

method pipe

pipe: <T extends NodeJS.ReadWriteStream>(
    stream: T,
    opts?: { end?: boolean }
) => T;

If file.contents is a Buffer, it will write it to the stream. If file.contents is a Stream, it will pipe it to the stream. If file.contents is null, it will do nothing.

namespace vm

module 'vm' {}

function createContext

createContext: {
    (initSandbox?: Context): Context;
    (initSandbox?: Context): Context;
};

function createScript

createScript: {
    (code: string, filename?: string): Script;
    (code: string, filename?: string): Script;
};

function runInContext

runInContext: {
    (code: string, context: Context, filename?: string): void;
    (code: string, context: Context, filename?: string): void;
};

function runInNewContext

runInNewContext: {
    (code: string, sandbox?: Context, filename?: string): void;
    (code: string, sandbox?: Context, filename?: string): void;
};

function runInThisContext

runInThisContext: {
    (code: string, filename?: string): void;
    (code: string, filename?: string): void;
};

interface Context

interface Context {}

interface Script

interface Script {}

method runInNewContext

runInNewContext: { (sandbox?: Context): void; (sandbox?: Context): void };

method runInThisContext

runInThisContext: { (): void; (): void };

namespace zlib

module 'zlib' {}

variable Z_ASCII

var Z_ASCII: number;

variable Z_BEST_COMPRESSION

var Z_BEST_COMPRESSION: number;

variable Z_BEST_SPEED

var Z_BEST_SPEED: number;

variable Z_BINARY

var Z_BINARY: number;

variable Z_BLOCK

var Z_BLOCK: number;

variable Z_BUF_ERROR

var Z_BUF_ERROR: number;

variable Z_DATA_ERROR

var Z_DATA_ERROR: number;

variable Z_DEFAULT_COMPRESSION

var Z_DEFAULT_COMPRESSION: number;

variable Z_DEFAULT_STRATEGY

var Z_DEFAULT_STRATEGY: number;

variable Z_DEFLATED

var Z_DEFLATED: number;

variable Z_ERRNO

var Z_ERRNO: number;

variable Z_FILTERED

var Z_FILTERED: number;

variable Z_FINISH

var Z_FINISH: number;

variable Z_FIXED

var Z_FIXED: number;

variable Z_FULL_FLUSH

var Z_FULL_FLUSH: number;

variable Z_HUFFMAN_ONLY

var Z_HUFFMAN_ONLY: number;

variable Z_MEM_ERROR

var Z_MEM_ERROR: number;

variable Z_NEED_DICT

var Z_NEED_DICT: number;

variable Z_NO_COMPRESSION

var Z_NO_COMPRESSION: number;

variable Z_NO_FLUSH

var Z_NO_FLUSH: number;

variable Z_NULL

var Z_NULL: number;

variable Z_OK

var Z_OK: number;

variable Z_PARTIAL_FLUSH

var Z_PARTIAL_FLUSH: number;

variable Z_RLE

var Z_RLE: number;

variable Z_STREAM_END

var Z_STREAM_END: number;

variable Z_STREAM_ERROR

var Z_STREAM_ERROR: number;

variable Z_SYNC_FLUSH

var Z_SYNC_FLUSH: number;

variable Z_TEXT

var Z_TEXT: number;

variable Z_TREES

var Z_TREES: number;

variable Z_UNKNOWN

var Z_UNKNOWN: number;

variable Z_VERSION_ERROR

var Z_VERSION_ERROR: number;

function createDeflate

createDeflate: {
    (options?: ZlibOptions): Deflate;
    (options?: ZlibOptions): Deflate;
};

function createDeflateRaw

createDeflateRaw: {
    (options?: ZlibOptions): DeflateRaw;
    (options?: ZlibOptions): DeflateRaw;
};

function createGunzip

createGunzip: {
    (options?: ZlibOptions): Gunzip;
    (options?: ZlibOptions): Gunzip;
};

function createGzip

createGzip: { (options?: ZlibOptions): Gzip; (options?: ZlibOptions): Gzip };

function createInflate

createInflate: {
    (options?: ZlibOptions): Inflate;
    (options?: ZlibOptions): Inflate;
};

function createInflateRaw

createInflateRaw: {
    (options?: ZlibOptions): InflateRaw;
    (options?: ZlibOptions): InflateRaw;
};

function createUnzip

createUnzip: { (options?: ZlibOptions): Unzip; (options?: ZlibOptions): Unzip };

function deflate

deflate: {
    (buf: Buffer, callback: (error: Error, result: any) => void): void;
    (buf: Buffer, callback: (error: Error, result: any) => void): void;
};

function deflateRaw

deflateRaw: {
    (buf: Buffer, callback: (error: Error, result: any) => void): void;
    (buf: Buffer, callback: (error: Error, result: any) => void): void;
};

function gunzip

gunzip: {
    (buf: Buffer, callback: (error: Error, result: any) => void): void;
    (buf: Buffer, callback: (error: Error, result: any) => void): void;
};

function gzip

gzip: {
    (buf: Buffer, callback: (error: Error, result: any) => void): void;
    (buf: Buffer, callback: (error: Error, result: any) => void): void;
};

function inflate

inflate: {
    (buf: Buffer, callback: (error: Error, result: any) => void): void;
    (buf: Buffer, callback: (error: Error, result: any) => void): void;
};

function inflateRaw

inflateRaw: {
    (buf: Buffer, callback: (error: Error, result: any) => void): void;
    (buf: Buffer, callback: (error: Error, result: any) => void): void;
};

function unzip

unzip: {
    (buf: Buffer, callback: (error: Error, result: any) => void): void;
    (buf: Buffer, callback: (error: Error, result: any) => void): void;
};

interface Deflate

interface Deflate extends stream.Transform {}

interface DeflateRaw

interface DeflateRaw extends stream.Transform {}

interface Gunzip

interface Gunzip extends stream.Transform {}

interface Gzip

interface Gzip extends stream.Transform {}

interface Inflate

interface Inflate extends stream.Transform {}

interface InflateRaw

interface InflateRaw extends stream.Transform {}

interface Unzip

interface Unzip extends stream.Transform {}

interface ZlibOptions

interface ZlibOptions {}

property chunkSize

chunkSize?: number;

property dictionary

dictionary?: any;

property level

level?: number;

property memLevel

memLevel?: number;

property strategy

strategy?: number;

property windowBits

windowBits?: number;

Package Files (7)

Dependencies (4)

Dev Dependencies (5)

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/gulp-svg2png.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/gulp-svg2png)

HTML

<a href="https://www.jsdocs.io/package/gulp-svg2png"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 2 years ago.
Package analyzed in 10967 ms.
Missing or incorrect documentation? Open an issue for this package.