asyncawait

  • Version 3.0.0
  • Published
  • 440 kB
  • 3 dependencies
  • MIT license

Install

npm i asyncawait
yarn add asyncawait
pnpm add asyncawait

Overview

async/await for node.js

Index

Variables

Namespaces

Variables

variable async

var async: types.Async;
  • Creates a suspendable function. Suspendable functions may use the await() function internally to suspend execution at arbitrary points, pending the results of internal asynchronous operations.

    Parameter fn

    Contains the body of the suspendable function. Calls to await() may appear inside this function.

    Returns

    {Function} A function of the form (...args) --> Promise. Any arguments passed to this function are passed through to fn. The returned promise is resolved when fn returns, or rejected if fn throws.

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 bluebird

                                            module 'bluebird' {}

                                              variable Promise

                                              var Promise: PromiseConstructor;

                                                interface Promise

                                                interface Promise<T> {}

                                                  method catch

                                                  catch: <TResult = never>(
                                                  onrejected?: (reason: any) => TResult | PromiseLike<TResult>
                                                  ) => Promise<T | TResult>;

                                                    method then

                                                    then: <TResult1 = T, TResult2 = never>(
                                                    onfulfilled?: (value: T) => TResult1 | PromiseLike<TResult1>,
                                                    onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>
                                                    ) => Promise<TResult1 | TResult2>;

                                                      interface Promise

                                                      interface Promise<T> {}

                                                        interface Promise

                                                        interface Promise<T> {}

                                                          property [Symbol.toStringTag]

                                                          readonly [Symbol.toStringTag]: string;

                                                            interface Promise

                                                            interface Promise<T> {}

                                                              method finally

                                                              finally: (onfinally?: (() => void) | undefined | null) => Promise<T>;

                                                                namespace chai

                                                                module 'chai' {}

                                                                  variable assert

                                                                  var assert: Assert;

                                                                    variable config

                                                                    var config: Config;

                                                                      function expect

                                                                      expect: (target: any, message?: string) => Expect;

                                                                        function use

                                                                        use: (fn: (chai: any, utils: any) => void) => any;

                                                                          class AssertionError

                                                                          class AssertionError {}

                                                                            constructor

                                                                            constructor(message: string, _props?: any, ssf?: Function);

                                                                              property message

                                                                              message: string;

                                                                                property name

                                                                                name: string;

                                                                                  property showDiff

                                                                                  showDiff: boolean;

                                                                                    property stack

                                                                                    stack: string;

                                                                                      interface Assert

                                                                                      interface Assert {}

                                                                                        method closeTo

                                                                                        closeTo: (act: number, exp: number, delta: number, msg?: string) => void;

                                                                                          method deepEqual

                                                                                          deepEqual: (act: any, exp: any, msg?: string) => void;

                                                                                            method deepProperty

                                                                                            deepProperty: (obj: Object, prop: string, msg?: string) => void;

                                                                                              method deepPropertyNotVal

                                                                                              deepPropertyNotVal: (obj: Object, prop: string, val: any, msg?: string) => void;

                                                                                                method deepPropertyVal

                                                                                                deepPropertyVal: (obj: Object, prop: string, val: any, msg?: string) => void;

                                                                                                  method doesNotThrow

                                                                                                  doesNotThrow: {
                                                                                                  (fn: Function, msg?: string): void;
                                                                                                  (fn: Function, regExp: RegExp): void;
                                                                                                  (fn: Function, errType: Function, msg?: string): void;
                                                                                                  (fn: Function, errType: Function, regExp: RegExp): void;
                                                                                                  };

                                                                                                    method equal

                                                                                                    equal: (act: any, exp: any, msg?: string) => void;

                                                                                                      method fail

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

                                                                                                        method ifError

                                                                                                        ifError: (val: any, msg?: string) => void;

                                                                                                          method include

                                                                                                          include: {
                                                                                                          (exp: string, inc: any, msg?: string): void;
                                                                                                          (exp: any[], inc: any, msg?: string): void;
                                                                                                          };

                                                                                                            method includeMembers

                                                                                                            includeMembers: (set1: any[], set2: any[], msg?: string) => void;

                                                                                                              method instanceOf

                                                                                                              instanceOf: (val: any, type: Function, msg?: string) => void;

                                                                                                                method isArray

                                                                                                                isArray: (val: any, msg?: string) => void;

                                                                                                                  method isBoolean

                                                                                                                  isBoolean: (val: any, msg?: string) => void;

                                                                                                                    method isDefined

                                                                                                                    isDefined: (val: any, msg?: string) => void;

                                                                                                                      method isFalse

                                                                                                                      isFalse: (val: any, msg?: string) => void;

                                                                                                                        method isFunction

                                                                                                                        isFunction: (val: any, msg?: string) => void;

                                                                                                                          method isNotArray

                                                                                                                          isNotArray: (val: any, msg?: string) => void;

                                                                                                                            method isNotBoolean

                                                                                                                            isNotBoolean: (val: any, msg?: string) => void;

                                                                                                                              method isNotFunction

                                                                                                                              isNotFunction: (val: any, msg?: string) => void;

                                                                                                                                method isNotNull

                                                                                                                                isNotNull: (val: any, msg?: string) => void;

                                                                                                                                  method isNotNumber

                                                                                                                                  isNotNumber: (val: any, msg?: string) => void;

                                                                                                                                    method isNotObject

                                                                                                                                    isNotObject: (val: any, msg?: string) => void;

                                                                                                                                      method isNotString

                                                                                                                                      isNotString: (val: any, msg?: string) => void;

                                                                                                                                        method isNull

                                                                                                                                        isNull: (val: any, msg?: string) => void;

                                                                                                                                          method isNumber

                                                                                                                                          isNumber: (val: any, msg?: string) => void;

                                                                                                                                            method isObject

                                                                                                                                            isObject: (val: any, msg?: string) => void;

                                                                                                                                              method isString

                                                                                                                                              isString: (val: any, msg?: string) => void;

                                                                                                                                                method isTrue

                                                                                                                                                isTrue: (val: any, msg?: string) => void;

                                                                                                                                                  method isUndefined

                                                                                                                                                  isUndefined: (val: any, msg?: string) => void;

                                                                                                                                                    method lengthOf

                                                                                                                                                    lengthOf: (exp: any, len: number, msg?: string) => void;

                                                                                                                                                      method match

                                                                                                                                                      match: (exp: any, re: RegExp, msg?: string) => void;

                                                                                                                                                        method notDeepEqual

                                                                                                                                                        notDeepEqual: (act: any, exp: any, msg?: string) => void;

                                                                                                                                                          method notDeepProperty

                                                                                                                                                          notDeepProperty: (obj: Object, prop: string, msg?: string) => void;

                                                                                                                                                            method notEqual

                                                                                                                                                            notEqual: (act: any, exp: any, msg?: string) => void;

                                                                                                                                                              method notInclude

                                                                                                                                                              notInclude: {
                                                                                                                                                              (exp: string, inc: any, msg?: string): void;
                                                                                                                                                              (exp: any[], inc: any, msg?: string): void;
                                                                                                                                                              };

                                                                                                                                                                method notInstanceOf

                                                                                                                                                                notInstanceOf: (val: any, type: Function, msg?: string) => void;

                                                                                                                                                                  method notMatch

                                                                                                                                                                  notMatch: (exp: any, re: RegExp, msg?: string) => void;

                                                                                                                                                                    method notOk

                                                                                                                                                                    notOk: (val: any, msg?: string) => void;

                                                                                                                                                                      method notProperty

                                                                                                                                                                      notProperty: (obj: Object, prop: string, msg?: string) => void;

                                                                                                                                                                        method notStrictEqual

                                                                                                                                                                        notStrictEqual: (act: any, exp: any, msg?: string) => void;

                                                                                                                                                                          method notTypeOf

                                                                                                                                                                          notTypeOf: (val: any, type: string, msg?: string) => void;

                                                                                                                                                                            method ok

                                                                                                                                                                            ok: (val: any, msg?: string) => void;

                                                                                                                                                                              method operator

                                                                                                                                                                              operator: (val: any, operator: string, val2: any, msg?: string) => void;

                                                                                                                                                                                method property

                                                                                                                                                                                property: (obj: Object, prop: string, msg?: string) => void;

                                                                                                                                                                                  method propertyNotVal

                                                                                                                                                                                  propertyNotVal: (obj: Object, prop: string, val: any, msg?: string) => void;

                                                                                                                                                                                    method propertyVal

                                                                                                                                                                                    propertyVal: (obj: Object, prop: string, val: any, msg?: string) => void;

                                                                                                                                                                                      method sameMembers

                                                                                                                                                                                      sameMembers: (set1: any[], set2: any[], msg?: string) => void;

                                                                                                                                                                                        method strictEqual

                                                                                                                                                                                        strictEqual: (act: any, exp: any, msg?: string) => void;

                                                                                                                                                                                          method throw

                                                                                                                                                                                          throw: {
                                                                                                                                                                                          (fn: Function, msg?: string): void;
                                                                                                                                                                                          (fn: Function, regExp: RegExp): void;
                                                                                                                                                                                          (fn: Function, errType: Function, msg?: string): void;
                                                                                                                                                                                          (fn: Function, errType: Function, regExp: RegExp): void;
                                                                                                                                                                                          };

                                                                                                                                                                                            method Throw

                                                                                                                                                                                            Throw: {
                                                                                                                                                                                            (fn: Function, msg?: string): void;
                                                                                                                                                                                            (fn: Function, regExp: RegExp): void;
                                                                                                                                                                                            (fn: Function, errType: Function, msg?: string): void;
                                                                                                                                                                                            (fn: Function, errType: Function, regExp: RegExp): void;
                                                                                                                                                                                            };

                                                                                                                                                                                              method throws

                                                                                                                                                                                              throws: {
                                                                                                                                                                                              (fn: Function, msg?: string): void;
                                                                                                                                                                                              (fn: Function, regExp: RegExp): void;
                                                                                                                                                                                              (fn: Function, errType: Function, msg?: string): void;
                                                                                                                                                                                              (fn: Function, errType: Function, regExp: RegExp): void;
                                                                                                                                                                                              };

                                                                                                                                                                                                method typeOf

                                                                                                                                                                                                typeOf: (val: any, type: string, msg?: string) => void;

                                                                                                                                                                                                  call signature

                                                                                                                                                                                                  (express: any, msg?: string): void;

                                                                                                                                                                                                    interface Assertions

                                                                                                                                                                                                    interface Assertions {}

                                                                                                                                                                                                      property checked

                                                                                                                                                                                                      checked: any;

                                                                                                                                                                                                        property disabled

                                                                                                                                                                                                        disabled: any;

                                                                                                                                                                                                          property empty

                                                                                                                                                                                                          empty: any;

                                                                                                                                                                                                            property exist

                                                                                                                                                                                                            exist: any;

                                                                                                                                                                                                              property hidden

                                                                                                                                                                                                              hidden: any;

                                                                                                                                                                                                                property selected

                                                                                                                                                                                                                selected: any;

                                                                                                                                                                                                                  property visible

                                                                                                                                                                                                                  visible: any;

                                                                                                                                                                                                                    method attr

                                                                                                                                                                                                                    attr: (name: string, value?: string) => any;

                                                                                                                                                                                                                      method class

                                                                                                                                                                                                                      class: (className: string) => any;

                                                                                                                                                                                                                        method css

                                                                                                                                                                                                                        css: (name: string, value?: string) => any;

                                                                                                                                                                                                                          method data

                                                                                                                                                                                                                          data: (name: string, value?: string) => any;

                                                                                                                                                                                                                            method html

                                                                                                                                                                                                                            html: (html: string) => any;

                                                                                                                                                                                                                              method id

                                                                                                                                                                                                                              id: (id: string) => any;

                                                                                                                                                                                                                                method text

                                                                                                                                                                                                                                text: (text: string) => any;

                                                                                                                                                                                                                                  method value

                                                                                                                                                                                                                                  value: (value: string) => any;

                                                                                                                                                                                                                                    interface Config

                                                                                                                                                                                                                                    interface Config {}

                                                                                                                                                                                                                                      property includeStack

                                                                                                                                                                                                                                      includeStack: boolean;

                                                                                                                                                                                                                                        interface Deep

                                                                                                                                                                                                                                        interface Deep {}

                                                                                                                                                                                                                                          property equal

                                                                                                                                                                                                                                          equal: Equal;

                                                                                                                                                                                                                                            property property

                                                                                                                                                                                                                                            property: Property;

                                                                                                                                                                                                                                              interface Equal

                                                                                                                                                                                                                                              interface Equal {}

                                                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                                                (value: any, message?: string): Expect;

                                                                                                                                                                                                                                                  interface Expect

                                                                                                                                                                                                                                                  interface Expect
                                                                                                                                                                                                                                                  extends LanguageChains,
                                                                                                                                                                                                                                                  NumericComparison,
                                                                                                                                                                                                                                                  TypeComparison,
                                                                                                                                                                                                                                                  Assertions {}

                                                                                                                                                                                                                                                    property a

                                                                                                                                                                                                                                                    a: TypeComparison;

                                                                                                                                                                                                                                                      property an

                                                                                                                                                                                                                                                      an: TypeComparison;

                                                                                                                                                                                                                                                        property arguments

                                                                                                                                                                                                                                                        arguments: Expect;

                                                                                                                                                                                                                                                          property Arguments

                                                                                                                                                                                                                                                          Arguments: Expect;

                                                                                                                                                                                                                                                            property contain

                                                                                                                                                                                                                                                            contain: Include;

                                                                                                                                                                                                                                                              property deep

                                                                                                                                                                                                                                                              deep: Deep;

                                                                                                                                                                                                                                                                property empty

                                                                                                                                                                                                                                                                empty: Expect;

                                                                                                                                                                                                                                                                  property eq

                                                                                                                                                                                                                                                                  eq: Equal;

                                                                                                                                                                                                                                                                    property eql

                                                                                                                                                                                                                                                                    eql: Equal;

                                                                                                                                                                                                                                                                      property eqls

                                                                                                                                                                                                                                                                      eqls: Equal;

                                                                                                                                                                                                                                                                        property equal

                                                                                                                                                                                                                                                                        equal: Equal;

                                                                                                                                                                                                                                                                          property equals

                                                                                                                                                                                                                                                                          equals: Equal;

                                                                                                                                                                                                                                                                            property exist

                                                                                                                                                                                                                                                                            exist: Expect;

                                                                                                                                                                                                                                                                              property false

                                                                                                                                                                                                                                                                              false: Expect;

                                                                                                                                                                                                                                                                                property haveOwnProperty

                                                                                                                                                                                                                                                                                haveOwnProperty: OwnProperty;

                                                                                                                                                                                                                                                                                  property include

                                                                                                                                                                                                                                                                                  include: Include;

                                                                                                                                                                                                                                                                                    property itself

                                                                                                                                                                                                                                                                                    itself: Expect;

                                                                                                                                                                                                                                                                                      property keys

                                                                                                                                                                                                                                                                                      keys: Keys;

                                                                                                                                                                                                                                                                                        property length

                                                                                                                                                                                                                                                                                        length: Length;

                                                                                                                                                                                                                                                                                          property lengthOf

                                                                                                                                                                                                                                                                                          lengthOf: Length;

                                                                                                                                                                                                                                                                                            property members

                                                                                                                                                                                                                                                                                            members: Members;

                                                                                                                                                                                                                                                                                              property not

                                                                                                                                                                                                                                                                                              not: Expect;

                                                                                                                                                                                                                                                                                                property null

                                                                                                                                                                                                                                                                                                null: Expect;

                                                                                                                                                                                                                                                                                                  property ok

                                                                                                                                                                                                                                                                                                  ok: Expect;

                                                                                                                                                                                                                                                                                                    property ownProperty

                                                                                                                                                                                                                                                                                                    ownProperty: OwnProperty;

                                                                                                                                                                                                                                                                                                      property property

                                                                                                                                                                                                                                                                                                      property: Property;

                                                                                                                                                                                                                                                                                                        property throw

                                                                                                                                                                                                                                                                                                        throw: Throw;

                                                                                                                                                                                                                                                                                                          property Throw

                                                                                                                                                                                                                                                                                                          Throw: Throw;

                                                                                                                                                                                                                                                                                                            property throws

                                                                                                                                                                                                                                                                                                            throws: Throw;

                                                                                                                                                                                                                                                                                                              property true

                                                                                                                                                                                                                                                                                                              true: Expect;

                                                                                                                                                                                                                                                                                                                property undefined

                                                                                                                                                                                                                                                                                                                undefined: Expect;

                                                                                                                                                                                                                                                                                                                  method closeTo

                                                                                                                                                                                                                                                                                                                  closeTo: (expected: number, delta: number, message?: string) => Expect;

                                                                                                                                                                                                                                                                                                                    method key

                                                                                                                                                                                                                                                                                                                    key: (string: string) => Expect;

                                                                                                                                                                                                                                                                                                                      method match

                                                                                                                                                                                                                                                                                                                      match: (RegularExpression: RegExp, message?: string) => Expect;

                                                                                                                                                                                                                                                                                                                        method respondTo

                                                                                                                                                                                                                                                                                                                        respondTo: (method: string, message?: string) => Expect;

                                                                                                                                                                                                                                                                                                                          method satisfy

                                                                                                                                                                                                                                                                                                                          satisfy: (matcher: Function, message?: string) => Expect;

                                                                                                                                                                                                                                                                                                                            method string

                                                                                                                                                                                                                                                                                                                            string: (string: string, message?: string) => Expect;

                                                                                                                                                                                                                                                                                                                              interface ExpectStatic

                                                                                                                                                                                                                                                                                                                              interface ExpectStatic {}

                                                                                                                                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                                                                                                                                (target: any): Expect;

                                                                                                                                                                                                                                                                                                                                  interface Include

                                                                                                                                                                                                                                                                                                                                  interface Include {}

                                                                                                                                                                                                                                                                                                                                    property keys

                                                                                                                                                                                                                                                                                                                                    keys: Keys;

                                                                                                                                                                                                                                                                                                                                      property members

                                                                                                                                                                                                                                                                                                                                      members: Members;

                                                                                                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                                                                                                        (value: Object, message?: string): Expect;

                                                                                                                                                                                                                                                                                                                                          call signature

                                                                                                                                                                                                                                                                                                                                          (value: string, message?: string): Expect;

                                                                                                                                                                                                                                                                                                                                            call signature

                                                                                                                                                                                                                                                                                                                                            (value: number, message?: string): Expect;

                                                                                                                                                                                                                                                                                                                                              interface InstanceOf

                                                                                                                                                                                                                                                                                                                                              interface InstanceOf {}

                                                                                                                                                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                                                                                                                                                (constructor: Object, message?: string): Expect;

                                                                                                                                                                                                                                                                                                                                                  interface Keys

                                                                                                                                                                                                                                                                                                                                                  interface Keys {}

                                                                                                                                                                                                                                                                                                                                                    call signature

                                                                                                                                                                                                                                                                                                                                                    (...keys: string[]): Expect;

                                                                                                                                                                                                                                                                                                                                                      call signature

                                                                                                                                                                                                                                                                                                                                                      (keys: any[]): Expect;

                                                                                                                                                                                                                                                                                                                                                        interface LanguageChains

                                                                                                                                                                                                                                                                                                                                                        interface LanguageChains {}

                                                                                                                                                                                                                                                                                                                                                          property and

                                                                                                                                                                                                                                                                                                                                                          and: Expect;

                                                                                                                                                                                                                                                                                                                                                            property at

                                                                                                                                                                                                                                                                                                                                                            at: Expect;

                                                                                                                                                                                                                                                                                                                                                              property be

                                                                                                                                                                                                                                                                                                                                                              be: Expect;

                                                                                                                                                                                                                                                                                                                                                                property been

                                                                                                                                                                                                                                                                                                                                                                been: Expect;

                                                                                                                                                                                                                                                                                                                                                                  property has

                                                                                                                                                                                                                                                                                                                                                                  has: Expect;

                                                                                                                                                                                                                                                                                                                                                                    property have

                                                                                                                                                                                                                                                                                                                                                                    have: Expect;

                                                                                                                                                                                                                                                                                                                                                                      property is

                                                                                                                                                                                                                                                                                                                                                                      is: Expect;

                                                                                                                                                                                                                                                                                                                                                                        property of

                                                                                                                                                                                                                                                                                                                                                                        of: Expect;

                                                                                                                                                                                                                                                                                                                                                                          property same

                                                                                                                                                                                                                                                                                                                                                                          same: Expect;

                                                                                                                                                                                                                                                                                                                                                                            property that

                                                                                                                                                                                                                                                                                                                                                                            that: Expect;

                                                                                                                                                                                                                                                                                                                                                                              property to

                                                                                                                                                                                                                                                                                                                                                                              to: Expect;

                                                                                                                                                                                                                                                                                                                                                                                property with

                                                                                                                                                                                                                                                                                                                                                                                with: Expect;

                                                                                                                                                                                                                                                                                                                                                                                  interface Length

                                                                                                                                                                                                                                                                                                                                                                                  interface Length extends LanguageChains, NumericComparison {}

                                                                                                                                                                                                                                                                                                                                                                                    call signature

                                                                                                                                                                                                                                                                                                                                                                                    (length: number, message?: string): Expect;

                                                                                                                                                                                                                                                                                                                                                                                      interface Members

                                                                                                                                                                                                                                                                                                                                                                                      interface Members {}

                                                                                                                                                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                                                                                                                                                        (set: any[], message?: string): Expect;

                                                                                                                                                                                                                                                                                                                                                                                          interface NumberComparer

                                                                                                                                                                                                                                                                                                                                                                                          interface NumberComparer {}

                                                                                                                                                                                                                                                                                                                                                                                            call signature

                                                                                                                                                                                                                                                                                                                                                                                            (value: number, message?: string): Expect;

                                                                                                                                                                                                                                                                                                                                                                                              interface NumericComparison

                                                                                                                                                                                                                                                                                                                                                                                              interface NumericComparison {}

                                                                                                                                                                                                                                                                                                                                                                                                property above

                                                                                                                                                                                                                                                                                                                                                                                                above: NumberComparer;

                                                                                                                                                                                                                                                                                                                                                                                                  property below

                                                                                                                                                                                                                                                                                                                                                                                                  below: NumberComparer;

                                                                                                                                                                                                                                                                                                                                                                                                    property greaterThan

                                                                                                                                                                                                                                                                                                                                                                                                    greaterThan: NumberComparer;

                                                                                                                                                                                                                                                                                                                                                                                                      property gt

                                                                                                                                                                                                                                                                                                                                                                                                      gt: NumberComparer;

                                                                                                                                                                                                                                                                                                                                                                                                        property gte

                                                                                                                                                                                                                                                                                                                                                                                                        gte: NumberComparer;

                                                                                                                                                                                                                                                                                                                                                                                                          property least

                                                                                                                                                                                                                                                                                                                                                                                                          least: NumberComparer;

                                                                                                                                                                                                                                                                                                                                                                                                            property lessThan

                                                                                                                                                                                                                                                                                                                                                                                                            lessThan: NumberComparer;

                                                                                                                                                                                                                                                                                                                                                                                                              property lt

                                                                                                                                                                                                                                                                                                                                                                                                              lt: NumberComparer;

                                                                                                                                                                                                                                                                                                                                                                                                                property lte

                                                                                                                                                                                                                                                                                                                                                                                                                lte: NumberComparer;

                                                                                                                                                                                                                                                                                                                                                                                                                  property most

                                                                                                                                                                                                                                                                                                                                                                                                                  most: NumberComparer;

                                                                                                                                                                                                                                                                                                                                                                                                                    method within

                                                                                                                                                                                                                                                                                                                                                                                                                    within: (start: number, finish: number, message?: string) => Expect;

                                                                                                                                                                                                                                                                                                                                                                                                                      interface OwnProperty

                                                                                                                                                                                                                                                                                                                                                                                                                      interface OwnProperty {}

                                                                                                                                                                                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                                                                                                                                                                                        (name: string, message?: string): Expect;

                                                                                                                                                                                                                                                                                                                                                                                                                          interface Property

                                                                                                                                                                                                                                                                                                                                                                                                                          interface Property {}

                                                                                                                                                                                                                                                                                                                                                                                                                            call signature

                                                                                                                                                                                                                                                                                                                                                                                                                            (name: string, value?: any, message?: string): Expect;

                                                                                                                                                                                                                                                                                                                                                                                                                              interface Throw

                                                                                                                                                                                                                                                                                                                                                                                                                              interface Throw {}

                                                                                                                                                                                                                                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                (): Expect;

                                                                                                                                                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                  (expected: string, message?: string): Expect;

                                                                                                                                                                                                                                                                                                                                                                                                                                    call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                    (expected: RegExp, message?: string): Expect;

                                                                                                                                                                                                                                                                                                                                                                                                                                      call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                      (constructor: Error, expected?: string, message?: string): Expect;

                                                                                                                                                                                                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                        (constructor: Error, expected?: RegExp, message?: string): Expect;

                                                                                                                                                                                                                                                                                                                                                                                                                                          call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                          (constructor: Function, expected?: string, message?: string): Expect;

                                                                                                                                                                                                                                                                                                                                                                                                                                            call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                            (constructor: Function, expected?: RegExp, message?: string): Expect;

                                                                                                                                                                                                                                                                                                                                                                                                                                              interface TypeComparison

                                                                                                                                                                                                                                                                                                                                                                                                                                              interface TypeComparison {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                property instanceof

                                                                                                                                                                                                                                                                                                                                                                                                                                                instanceof: InstanceOf;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property instanceOf

                                                                                                                                                                                                                                                                                                                                                                                                                                                  instanceOf: InstanceOf;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                    (type: string, message?: string): Expect;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      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: NodeBuffer, stderr: NodeBuffer) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                        ): ChildProcess;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        (
                                                                                                                                                                                                                                                                                                                                                                                                                                                        command: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                        callback: (error: Error, stdout: NodeBuffer, stderr: NodeBuffer) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                        ): ChildProcess;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                          function execFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                          execFile: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                          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: NodeBuffer, stderr: NodeBuffer) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => ChildProcess;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            function fork

                                                                                                                                                                                                                                                                                                                                                                                                                                                            fork: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                            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;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ChildProcess

                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ChildProcess extends NodeEventEmitter {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property pid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  pid: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property stderr

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    stderr: ReadableStream;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property stdin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      stdin: WritableStream;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property stdout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        stdout: ReadableStream;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method disconnect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          disconnect: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method kill

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method send

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              send: (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;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function disconnect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              disconnect: (callback?: Function) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function emit

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function fork

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  fork: (env?: any) => Worker;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function listeners

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function on

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function once

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function removeAllListeners

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function removeListener

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function setMaxListeners

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              setMaxListeners: (n: number) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function setupMaster

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                setupMaster: (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;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function createCipheriv

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              createCipheriv: (algorithm: string, key: any, iv: any) => Cipher;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function createCredentials

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                createCredentials: (details: CredentialDetails) => Credentials;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function createDiffieHellman

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function createHash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    createHash: (algorithm: string) => Hash;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function createHmac

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      createHmac: (algorithm: string, key: string) => Hmac;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function createSign

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        createSign: (algorithm: string) => Signer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function createVerify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          createVerify: (algorith: string) => Verify;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function getDiffieHellman

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getDiffieHellman: (group_name: string) => DiffieHellman;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function pbkdf2

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function pseudoRandomBytes

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function randomBytes

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface Cipher

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface Cipher {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method createDecipher

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      createDecipher: (algorithm: string, password: any) => Decipher;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method createDecipheriv

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        createDecipheriv: (algorithm: string, key: any, iv: any) => Decipher;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method final

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          final: (output_encoding?: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method setAutoPadding

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            setAutoPadding: (auto_padding: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method update

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              update: (data: any, 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: (output_encoding?: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method setAutoPadding

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        setAutoPadding: (auto_padding: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method update

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          update: (data: any, input_encoding?: string, output_encoding?: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface DiffieHellman

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface DiffieHellman {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method computeSecret

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              computeSecret: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              other_public_key: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              input_encoding?: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              output_encoding?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method generateKeys

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                generateKeys: (encoding?: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getGenerator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getGenerator: (encoding: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getPrime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getPrime: (encoding?: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getPrivateKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getPrivateKey: (encoding?: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getPublicKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getPublicKey: (encoding?: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method setPrivateKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          setPrivateKey: (public_key: string, encoding?: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method setPublicKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            setPublicKey: (public_key: string, encoding?: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface Hash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface Hash {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method digest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                digest: (encoding?: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method update

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  update: (data: any, input_encoding?: string) => Hash;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface Hmac

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface Hmac {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method digest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      digest: (encoding?: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method update

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        update: (data: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface Signer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface Signer {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method sign

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            sign: (private_key: string, output_format: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method update

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              update: (data: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Verify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Verify {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method update

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  update: (data: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method verify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    verify: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    object: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    signature: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    signature_format?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      namespace dgram

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      module 'dgram' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function createSocket

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        createSocket: (type: string, callback?: Function) => Socket;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface Socket

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface Socket extends NodeEventEmitter {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property address

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method addMembership

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              addMembership: (multicastAddress: string, multicastInterface?: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method bind

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  close: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method dropMembership

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    dropMembership: (multicastAddress: string, multicastInterface?: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method send

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      send: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      buf: NodeBuffer,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      offset: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      length: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      port: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      address: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      callback?: Function
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method setBroadcast

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        setBroadcast: (flag: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method setMulticastLoopback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          setMulticastLoopback: (flag: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method setMulticastTTL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            setMulticastTTL: (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;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function resolve

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  resolve: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  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[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function resolve6

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function resolveCname

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function resolveMx

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function resolveNs

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function resolveSrv

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function resolveTxt

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function reverse

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    namespace domain

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    module 'domain' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      create: () => Domain;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class Domain

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class Domain extends events.EventEmitter {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method add

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          add: (emitter: NodeEventEmitter) => 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: NodeEventEmitter) => 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 NodeEventEmitter {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    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 fibers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      module 'fibers' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        variable current

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        var current: Fiber;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          variable fibersCreated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          var fibersCreated: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            variable poolSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            var poolSize: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function Fiber

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Fiber: typeof Fiber;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function yield

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                yield: (value?: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  namespace fibers/future

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  module 'fibers/future' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class Future

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class Future {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor();

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method detach

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        detach: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method get

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          get: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isResolved

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isResolved: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method proxy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              proxy: (future: Future) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method proxyErrors

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                proxyErrors: (futureOrList: any) => Future;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method resolve

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  resolve: (fn: Function) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method resolver

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    resolver: () => Function;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method resolveSuccess

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      resolveSuccess: (fn: Function) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method return

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        return: (result?: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method throw

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          throw: (error: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method wait

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            static wait: { (future: Future): any; (future_list: Future[]): any };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method wrap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              static wrap: (fn: Function) => Future;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                namespace fs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                module 'fs' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function appendFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  appendFile: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  filename: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  data: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  options: { encoding?: string; mode?: number; flag?: string },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  callback?: (err: ErrnoException) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  filename: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  data: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  options: { encoding?: string; mode?: string; flag?: string },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  callback?: (err: ErrnoException) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (filename: string, data: any, callback?: (err: 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;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function chmod

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function chmodSync

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function chown

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function chownSync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            chownSync: (path: string, uid: number, gid: number) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              close: (fd: number, callback?: (err?: ErrnoException) => void) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function closeSync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                closeSync: (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;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function createWriteStream

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function exists

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function existsSync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        existsSync: (path: string) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function fchmod

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function fchmodSync

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function fchown

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function fchownSync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                fchownSync: (fd: number, uid: number, gid: number) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function fstat

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function fstatSync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    fstatSync: (fd: number) => Stats;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function fsync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      fsync: (fd: number, callback?: (err?: ErrnoException) => void) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function fsyncSync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        fsyncSync: (fd: number) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function ftruncate

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function ftruncateSync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ftruncateSync: (fd: number, len?: number) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function futimes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              futimes: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              fd: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              atime: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              mtime: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              callback?: (err?: ErrnoException) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function futimesSync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                futimesSync: (fd: number, atime: number, mtime: number) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function lchmod

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function lchmodSync

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function lchown

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function lchownSync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        lchownSync: (path: string, uid: number, gid: number) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          link: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          srcpath: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          dstpath: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          callback?: (err?: ErrnoException) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function linkSync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            linkSync: (srcpath: string, dstpath: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function lstat

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function lstatSync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                lstatSync: (path: string) => Stats;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function mkdir

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function mkdirSync

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function open

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function openSync

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function read

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          read: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          fd: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          buffer: NodeBuffer,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          offset: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          length: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          position: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          callback?: (err: ErrnoException, bytesRead: number, buffer: NodeBuffer) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function readdir

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function readdirSync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readdirSync: (path: string) => string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function readFile

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function readFileSync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readFileSync: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (filename: string, options?: { flag?: string }): NodeBuffer;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (filename: string, options: { encoding: string; flag?: string }): string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readlink: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    path: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    callback?: (err: ErrnoException, linkString: string) => any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function readlinkSync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readlinkSync: (path: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function readSync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readSync: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        fd: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        buffer: NodeBuffer,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        offset: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        length: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        position: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function realpath

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function realpathSync

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function rename

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function renameSync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                renameSync: (oldPath: string, newPath: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function rmdir

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  rmdir: (path: string, callback?: (err?: ErrnoException) => void) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function rmdirSync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    rmdirSync: (path: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function stat

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function statSync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        statSync: (path: string) => Stats;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          symlink: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          srcpath: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          dstpath: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type?: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          callback?: (err?: ErrnoException) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function symlinkSync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            symlinkSync: (srcpath: string, dstpath: string, type?: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function truncate

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function truncateSync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                truncateSync: (path: string, len?: number) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  unlink: (path: string, callback?: (err?: ErrnoException) => void) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function unlinkSync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    unlinkSync: (path: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function unwatchFile

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function utimes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        utimes: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        path: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        atime: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        mtime: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        callback?: (err?: ErrnoException) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function utimesSync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          utimesSync: (path: string, atime: number, mtime: number) => 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;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              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;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function write

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                write: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                fd: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                buffer: NodeBuffer,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                offset: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                length: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                position: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                callback?: (err: ErrnoException, written: number, buffer: NodeBuffer) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function writeFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  writeFile: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (filename: string, data: any, callback?: (err: ErrnoException) => void): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  filename: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  data: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  options: { encoding?: string; mode?: number; flag?: string },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  callback?: (err: ErrnoException) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  filename: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  data: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  options: { encoding?: string; mode?: string; flag?: string },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  callback?: (err: 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;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function writeSync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      writeSync: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      fd: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      buffer: NodeBuffer,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      offset: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      length: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      position: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface FSWatcher

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface FSWatcher extends NodeEventEmitter {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          close: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ReadStream

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ReadStream extends ReadableStream {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              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;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  nlink: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property rdev

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    rdev: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property size

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      size: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property uid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        uid: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isBlockDevice

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isBlockDevice: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isCharacterDevice

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isCharacterDevice: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isDirectory

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isDirectory: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isFIFO

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isFIFO: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isFile: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isSocket

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isSocket: () => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isSymbolicLink: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface WriteStream

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface WriteStream extends WritableStream {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          namespace http

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          module 'http' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            variable globalAgent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            var globalAgent: Agent;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              variable STATUS_CODES

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              var STATUS_CODES: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function createClient

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                createClient: (port?: number, host?: string) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function createServer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  createServer: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  requestListener?: (request: ServerRequest, response: ServerResponse) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Server;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function get

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    get: (options: any, callback?: Function) => ClientRequest;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function request

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      request: (options: any, callback?: Function) => ClientRequest;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Agent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Agent {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property maxSockets

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          maxSockets: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property requests

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            requests: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property sockets

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              sockets: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ClientRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface ClientRequest extends NodeEventEmitter, WritableStream {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method abort

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  abort: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method end

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method setNoDelay

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      setNoDelay: (noDelay?: Function) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method setSocketKeepAlive

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        setSocketKeepAlive: (enable?: boolean, initialDelay?: number) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method setTimeout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          setTimeout: (timeout: number, callback?: Function) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method write

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            write: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (buffer: NodeBuffer): boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (buffer: NodeBuffer, 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 NodeEventEmitter, ReadableStream {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property headers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                headers: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property httpVersion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  httpVersion: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property statusCode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    statusCode: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property trailers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      trailers: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method pause

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        pause: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method resume

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          resume: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method setEncoding

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            setEncoding: (encoding?: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface Server

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface Server extends NodeEventEmitter {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property maxHeadersCount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                maxHeadersCount: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  close: (cb?: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method listen

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ServerRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ServerRequest extends NodeEventEmitter, ReadableStream {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property connection

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        connection: net.NodeSocket;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property headers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          headers: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property httpVersion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            httpVersion: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property method

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property trailers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                trailers: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property url

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  url: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method pause

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    pause: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method resume

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      resume: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method setEncoding

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        setEncoding: (encoding?: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ServerResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ServerResponse extends NodeEventEmitter, WritableStream {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property sendDate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            sendDate: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property statusCode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              statusCode: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method addTrailers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                addTrailers: (headers: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method end

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  end: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (buffer: NodeBuffer, 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;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method