angular2

  • Version 2.0.0-beta.21
  • Published
  • No dependencies
  • MIT license

Install

npm i angular2
yarn add angular2
pnpm add angular2

Overview

Angular 2 - a web framework for modern web apps

Index

Namespaces

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 deepStrictEqual

          deepStrictEqual: (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 notDeepStrictEqual

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

                        function notEqual

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

                          function notStrictEqual

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

                            function ok

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

                              function strictEqual

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

                                class AssertionError

                                class AssertionError implements Error {}

                                  constructor

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

                                    property actual

                                    actual: any;

                                      property expected

                                      expected: any;

                                        property generatedMessage

                                        generatedMessage: boolean;

                                          property message

                                          message: string;

                                            property name

                                            name: string;

                                              property operator

                                              operator: string;

                                                namespace buffer

                                                module 'buffer' {}
                                                • ********************************************** * MODULES * * **********************************************

                                                variable INSPECT_MAX_BYTES

                                                var INSPECT_MAX_BYTES: number;

                                                  namespace child_process

                                                  module 'child_process' {}

                                                    function exec

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

                                                      function execFile

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

                                                        function execFileSync

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

                                                          function execSync

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

                                                            function fork

                                                            fork: (
                                                            modulePath: string,
                                                            args?: string[],
                                                            options?: {
                                                            cwd?: string;
                                                            env?: any;
                                                            execPath?: string;
                                                            execArgv?: string[];
                                                            silent?: boolean;
                                                            uid?: number;
                                                            gid?: number;
                                                            }
                                                            ) => ChildProcess;

                                                              function spawn

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

                                                                function spawnSync

                                                                spawnSync: (
                                                                command: string,
                                                                args?: string[],
                                                                options?: {
                                                                cwd?: string;
                                                                input?: string | Buffer;
                                                                stdio?: any;
                                                                env?: any;
                                                                uid?: number;
                                                                gid?: number;
                                                                timeout?: number;
                                                                maxBuffer?: number;
                                                                killSignal?: string;
                                                                encoding?: string;
                                                                }
                                                                ) => {
                                                                pid: number;
                                                                output: string[];
                                                                stdout: string | Buffer;
                                                                stderr: string | Buffer;
                                                                status: number;
                                                                signal: string;
                                                                error: Error;
                                                                };

                                                                  interface ChildProcess

                                                                  interface ChildProcess extends events.EventEmitter {}

                                                                    property pid

                                                                    pid: number;

                                                                      property stderr

                                                                      stderr: stream.Readable;

                                                                        property stdin

                                                                        stdin: stream.Writable;

                                                                          property stdout

                                                                          stdout: stream.Readable;

                                                                            method disconnect

                                                                            disconnect: () => void;

                                                                              method kill

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

                                                                                method send

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

                                                                                  method unref

                                                                                  unref: () => 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 constants

                                                                                                                                              module 'constants' {}

                                                                                                                                                variable DH_CHECK_P_NOT_PRIME

                                                                                                                                                var DH_CHECK_P_NOT_PRIME: number;

                                                                                                                                                  variable DH_CHECK_P_NOT_SAFE_PRIME

                                                                                                                                                  var DH_CHECK_P_NOT_SAFE_PRIME: number;

                                                                                                                                                    variable DH_NOT_SUITABLE_GENERATOR

                                                                                                                                                    var DH_NOT_SUITABLE_GENERATOR: number;

                                                                                                                                                      variable DH_UNABLE_TO_CHECK_GENERATOR

                                                                                                                                                      var DH_UNABLE_TO_CHECK_GENERATOR: number;

                                                                                                                                                        variable E2BIG

                                                                                                                                                        var E2BIG: number;

                                                                                                                                                          variable EACCES

                                                                                                                                                          var EACCES: number;

                                                                                                                                                            variable EADDRINUSE

                                                                                                                                                            var EADDRINUSE: number;

                                                                                                                                                              variable EADDRNOTAVAIL

                                                                                                                                                              var EADDRNOTAVAIL: number;

                                                                                                                                                                variable EAFNOSUPPORT

                                                                                                                                                                var EAFNOSUPPORT: number;

                                                                                                                                                                  variable EAGAIN

                                                                                                                                                                  var EAGAIN: number;

                                                                                                                                                                    variable EALREADY

                                                                                                                                                                    var EALREADY: number;

                                                                                                                                                                      variable EBADF

                                                                                                                                                                      var EBADF: number;

                                                                                                                                                                        variable EBADMSG

                                                                                                                                                                        var EBADMSG: number;

                                                                                                                                                                          variable EBUSY

                                                                                                                                                                          var EBUSY: number;

                                                                                                                                                                            variable ECANCELED

                                                                                                                                                                            var ECANCELED: number;

                                                                                                                                                                              variable ECHILD

                                                                                                                                                                              var ECHILD: number;

                                                                                                                                                                                variable ECONNABORTED

                                                                                                                                                                                var ECONNABORTED: number;

                                                                                                                                                                                  variable ECONNREFUSED

                                                                                                                                                                                  var ECONNREFUSED: number;

                                                                                                                                                                                    variable ECONNRESET

                                                                                                                                                                                    var ECONNRESET: number;

                                                                                                                                                                                      variable EDEADLK

                                                                                                                                                                                      var EDEADLK: number;

                                                                                                                                                                                        variable EDESTADDRREQ

                                                                                                                                                                                        var EDESTADDRREQ: number;

                                                                                                                                                                                          variable EDOM

                                                                                                                                                                                          var EDOM: number;

                                                                                                                                                                                            variable EEXIST

                                                                                                                                                                                            var EEXIST: number;

                                                                                                                                                                                              variable EFAULT

                                                                                                                                                                                              var EFAULT: number;

                                                                                                                                                                                                variable EFBIG

                                                                                                                                                                                                var EFBIG: number;

                                                                                                                                                                                                  variable EHOSTUNREACH

                                                                                                                                                                                                  var EHOSTUNREACH: number;

                                                                                                                                                                                                    variable EIDRM

                                                                                                                                                                                                    var EIDRM: number;

                                                                                                                                                                                                      variable EILSEQ

                                                                                                                                                                                                      var EILSEQ: number;

                                                                                                                                                                                                        variable EINPROGRESS

                                                                                                                                                                                                        var EINPROGRESS: number;

                                                                                                                                                                                                          variable EINTR

                                                                                                                                                                                                          var EINTR: number;

                                                                                                                                                                                                            variable EINVAL

                                                                                                                                                                                                            var EINVAL: number;

                                                                                                                                                                                                              variable EIO

                                                                                                                                                                                                              var EIO: number;

                                                                                                                                                                                                                variable EISCONN

                                                                                                                                                                                                                var EISCONN: number;

                                                                                                                                                                                                                  variable EISDIR

                                                                                                                                                                                                                  var EISDIR: number;

                                                                                                                                                                                                                    variable ELOOP

                                                                                                                                                                                                                    var ELOOP: number;

                                                                                                                                                                                                                      variable EMFILE

                                                                                                                                                                                                                      var EMFILE: number;
                                                                                                                                                                                                                        var EMLINK: number;

                                                                                                                                                                                                                          variable EMSGSIZE

                                                                                                                                                                                                                          var EMSGSIZE: number;

                                                                                                                                                                                                                            variable ENAMETOOLONG

                                                                                                                                                                                                                            var ENAMETOOLONG: number;

                                                                                                                                                                                                                              variable ENETDOWN

                                                                                                                                                                                                                              var ENETDOWN: number;

                                                                                                                                                                                                                                variable ENETRESET

                                                                                                                                                                                                                                var ENETRESET: number;

                                                                                                                                                                                                                                  variable ENETUNREACH

                                                                                                                                                                                                                                  var ENETUNREACH: number;

                                                                                                                                                                                                                                    variable ENFILE

                                                                                                                                                                                                                                    var ENFILE: number;

                                                                                                                                                                                                                                      variable ENGINE_METHOD_ALL

                                                                                                                                                                                                                                      var ENGINE_METHOD_ALL: number;

                                                                                                                                                                                                                                        variable ENGINE_METHOD_CIPHERS

                                                                                                                                                                                                                                        var ENGINE_METHOD_CIPHERS: number;

                                                                                                                                                                                                                                          variable ENGINE_METHOD_DH

                                                                                                                                                                                                                                          var ENGINE_METHOD_DH: number;

                                                                                                                                                                                                                                            variable ENGINE_METHOD_DIGESTS

                                                                                                                                                                                                                                            var ENGINE_METHOD_DIGESTS: number;

                                                                                                                                                                                                                                              variable ENGINE_METHOD_DSA

                                                                                                                                                                                                                                              var ENGINE_METHOD_DSA: number;

                                                                                                                                                                                                                                                variable ENGINE_METHOD_ECDH

                                                                                                                                                                                                                                                var ENGINE_METHOD_ECDH: number;

                                                                                                                                                                                                                                                  variable ENGINE_METHOD_ECDSA

                                                                                                                                                                                                                                                  var ENGINE_METHOD_ECDSA: number;

                                                                                                                                                                                                                                                    variable ENGINE_METHOD_NONE

                                                                                                                                                                                                                                                    var ENGINE_METHOD_NONE: number;

                                                                                                                                                                                                                                                      variable ENGINE_METHOD_PKEY_ASN1_METHS

                                                                                                                                                                                                                                                      var ENGINE_METHOD_PKEY_ASN1_METHS: number;

                                                                                                                                                                                                                                                        variable ENGINE_METHOD_PKEY_METHS

                                                                                                                                                                                                                                                        var ENGINE_METHOD_PKEY_METHS: number;

                                                                                                                                                                                                                                                          variable ENGINE_METHOD_RAND

                                                                                                                                                                                                                                                          var ENGINE_METHOD_RAND: number;

                                                                                                                                                                                                                                                            variable ENGINE_METHOD_STORE

                                                                                                                                                                                                                                                            var ENGINE_METHOD_STORE: number;

                                                                                                                                                                                                                                                              variable ENOBUFS

                                                                                                                                                                                                                                                              var ENOBUFS: number;

                                                                                                                                                                                                                                                                variable ENODATA

                                                                                                                                                                                                                                                                var ENODATA: number;

                                                                                                                                                                                                                                                                  variable ENODEV

                                                                                                                                                                                                                                                                  var ENODEV: number;

                                                                                                                                                                                                                                                                    variable ENOENT

                                                                                                                                                                                                                                                                    var ENOENT: number;

                                                                                                                                                                                                                                                                      variable ENOEXEC

                                                                                                                                                                                                                                                                      var ENOEXEC: number;

                                                                                                                                                                                                                                                                        variable ENOLCK

                                                                                                                                                                                                                                                                        var ENOLCK: number;
                                                                                                                                                                                                                                                                          var ENOLINK: number;

                                                                                                                                                                                                                                                                            variable ENOMEM

                                                                                                                                                                                                                                                                            var ENOMEM: number;

                                                                                                                                                                                                                                                                              variable ENOMSG

                                                                                                                                                                                                                                                                              var ENOMSG: number;

                                                                                                                                                                                                                                                                                variable ENOPROTOOPT

                                                                                                                                                                                                                                                                                var ENOPROTOOPT: number;

                                                                                                                                                                                                                                                                                  variable ENOSPC

                                                                                                                                                                                                                                                                                  var ENOSPC: number;

                                                                                                                                                                                                                                                                                    variable ENOSR

                                                                                                                                                                                                                                                                                    var ENOSR: number;

                                                                                                                                                                                                                                                                                      variable ENOSTR

                                                                                                                                                                                                                                                                                      var ENOSTR: number;

                                                                                                                                                                                                                                                                                        variable ENOSYS

                                                                                                                                                                                                                                                                                        var ENOSYS: number;

                                                                                                                                                                                                                                                                                          variable ENOTCONN

                                                                                                                                                                                                                                                                                          var ENOTCONN: number;

                                                                                                                                                                                                                                                                                            variable ENOTDIR

                                                                                                                                                                                                                                                                                            var ENOTDIR: number;

                                                                                                                                                                                                                                                                                              variable ENOTEMPTY

                                                                                                                                                                                                                                                                                              var ENOTEMPTY: number;

                                                                                                                                                                                                                                                                                                variable ENOTSOCK

                                                                                                                                                                                                                                                                                                var ENOTSOCK: number;

                                                                                                                                                                                                                                                                                                  variable ENOTSUP

                                                                                                                                                                                                                                                                                                  var ENOTSUP: number;

                                                                                                                                                                                                                                                                                                    variable ENOTTY

                                                                                                                                                                                                                                                                                                    var ENOTTY: number;

                                                                                                                                                                                                                                                                                                      variable ENXIO

                                                                                                                                                                                                                                                                                                      var ENXIO: number;

                                                                                                                                                                                                                                                                                                        variable EOPNOTSUPP

                                                                                                                                                                                                                                                                                                        var EOPNOTSUPP: number;

                                                                                                                                                                                                                                                                                                          variable EOVERFLOW

                                                                                                                                                                                                                                                                                                          var EOVERFLOW: number;

                                                                                                                                                                                                                                                                                                            variable EPERM

                                                                                                                                                                                                                                                                                                            var EPERM: number;

                                                                                                                                                                                                                                                                                                              variable EPIPE

                                                                                                                                                                                                                                                                                                              var EPIPE: number;

                                                                                                                                                                                                                                                                                                                variable EPROTO

                                                                                                                                                                                                                                                                                                                var EPROTO: number;

                                                                                                                                                                                                                                                                                                                  variable EPROTONOSUPPORT

                                                                                                                                                                                                                                                                                                                  var EPROTONOSUPPORT: number;

                                                                                                                                                                                                                                                                                                                    variable EPROTOTYPE

                                                                                                                                                                                                                                                                                                                    var EPROTOTYPE: number;

                                                                                                                                                                                                                                                                                                                      variable ERANGE

                                                                                                                                                                                                                                                                                                                      var ERANGE: number;

                                                                                                                                                                                                                                                                                                                        variable EROFS

                                                                                                                                                                                                                                                                                                                        var EROFS: number;

                                                                                                                                                                                                                                                                                                                          variable ESPIPE

                                                                                                                                                                                                                                                                                                                          var ESPIPE: number;

                                                                                                                                                                                                                                                                                                                            variable ESRCH

                                                                                                                                                                                                                                                                                                                            var ESRCH: number;

                                                                                                                                                                                                                                                                                                                              variable ETIME

                                                                                                                                                                                                                                                                                                                              var ETIME: number;

                                                                                                                                                                                                                                                                                                                                variable ETIMEDOUT

                                                                                                                                                                                                                                                                                                                                var ETIMEDOUT: number;

                                                                                                                                                                                                                                                                                                                                  variable ETXTBSY

                                                                                                                                                                                                                                                                                                                                  var ETXTBSY: number;

                                                                                                                                                                                                                                                                                                                                    variable EWOULDBLOCK

                                                                                                                                                                                                                                                                                                                                    var EWOULDBLOCK: number;

                                                                                                                                                                                                                                                                                                                                      variable EXDEV

                                                                                                                                                                                                                                                                                                                                      var EXDEV: number;

                                                                                                                                                                                                                                                                                                                                        variable F_OK

                                                                                                                                                                                                                                                                                                                                        var F_OK: number;

                                                                                                                                                                                                                                                                                                                                          variable NPN_ENABLED

                                                                                                                                                                                                                                                                                                                                          var NPN_ENABLED: number;

                                                                                                                                                                                                                                                                                                                                            variable O_APPEND

                                                                                                                                                                                                                                                                                                                                            var O_APPEND: number;

                                                                                                                                                                                                                                                                                                                                              variable O_CREAT

                                                                                                                                                                                                                                                                                                                                              var O_CREAT: number;

                                                                                                                                                                                                                                                                                                                                                variable O_EXCL

                                                                                                                                                                                                                                                                                                                                                var O_EXCL: number;

                                                                                                                                                                                                                                                                                                                                                  variable O_RDONLY

                                                                                                                                                                                                                                                                                                                                                  var O_RDONLY: number;

                                                                                                                                                                                                                                                                                                                                                    variable O_RDWR

                                                                                                                                                                                                                                                                                                                                                    var O_RDWR: number;

                                                                                                                                                                                                                                                                                                                                                      variable O_TRUNC

                                                                                                                                                                                                                                                                                                                                                      var O_TRUNC: number;

                                                                                                                                                                                                                                                                                                                                                        variable O_WRONLY

                                                                                                                                                                                                                                                                                                                                                        var O_WRONLY: number;

                                                                                                                                                                                                                                                                                                                                                          variable POINT_CONVERSION_COMPRESSED

                                                                                                                                                                                                                                                                                                                                                          var POINT_CONVERSION_COMPRESSED: number;

                                                                                                                                                                                                                                                                                                                                                            variable POINT_CONVERSION_HYBRID

                                                                                                                                                                                                                                                                                                                                                            var POINT_CONVERSION_HYBRID: number;

                                                                                                                                                                                                                                                                                                                                                              variable POINT_CONVERSION_UNCOMPRESSED

                                                                                                                                                                                                                                                                                                                                                              var POINT_CONVERSION_UNCOMPRESSED: number;

                                                                                                                                                                                                                                                                                                                                                                variable R_OK

                                                                                                                                                                                                                                                                                                                                                                var R_OK: number;

                                                                                                                                                                                                                                                                                                                                                                  variable RSA_NO_PADDING

                                                                                                                                                                                                                                                                                                                                                                  var RSA_NO_PADDING: number;

                                                                                                                                                                                                                                                                                                                                                                    variable RSA_PKCS1_OAEP_PADDING

                                                                                                                                                                                                                                                                                                                                                                    var RSA_PKCS1_OAEP_PADDING: number;

                                                                                                                                                                                                                                                                                                                                                                      variable RSA_PKCS1_PADDING

                                                                                                                                                                                                                                                                                                                                                                      var RSA_PKCS1_PADDING: number;

                                                                                                                                                                                                                                                                                                                                                                        variable RSA_PKCS1_PSS_PADDING

                                                                                                                                                                                                                                                                                                                                                                        var RSA_PKCS1_PSS_PADDING: number;

                                                                                                                                                                                                                                                                                                                                                                          variable RSA_SSLV23_PADDING

                                                                                                                                                                                                                                                                                                                                                                          var RSA_SSLV23_PADDING: number;

                                                                                                                                                                                                                                                                                                                                                                            variable RSA_X931_PADDING

                                                                                                                                                                                                                                                                                                                                                                            var RSA_X931_PADDING: number;

                                                                                                                                                                                                                                                                                                                                                                              variable S_IFCHR

                                                                                                                                                                                                                                                                                                                                                                              var S_IFCHR: number;

                                                                                                                                                                                                                                                                                                                                                                                variable S_IFDIR

                                                                                                                                                                                                                                                                                                                                                                                var S_IFDIR: number;

                                                                                                                                                                                                                                                                                                                                                                                  variable S_IFLNK

                                                                                                                                                                                                                                                                                                                                                                                  var S_IFLNK: number;

                                                                                                                                                                                                                                                                                                                                                                                    variable S_IFMT

                                                                                                                                                                                                                                                                                                                                                                                    var S_IFMT: number;

                                                                                                                                                                                                                                                                                                                                                                                      variable S_IFREG

                                                                                                                                                                                                                                                                                                                                                                                      var S_IFREG: number;

                                                                                                                                                                                                                                                                                                                                                                                        variable SIGABRT

                                                                                                                                                                                                                                                                                                                                                                                        var SIGABRT: number;

                                                                                                                                                                                                                                                                                                                                                                                          variable SIGBREAK

                                                                                                                                                                                                                                                                                                                                                                                          var SIGBREAK: number;

                                                                                                                                                                                                                                                                                                                                                                                            variable SIGFPE

                                                                                                                                                                                                                                                                                                                                                                                            var SIGFPE: number;

                                                                                                                                                                                                                                                                                                                                                                                              variable SIGHUP

                                                                                                                                                                                                                                                                                                                                                                                              var SIGHUP: number;

                                                                                                                                                                                                                                                                                                                                                                                                variable SIGILL

                                                                                                                                                                                                                                                                                                                                                                                                var SIGILL: number;

                                                                                                                                                                                                                                                                                                                                                                                                  variable SIGINT

                                                                                                                                                                                                                                                                                                                                                                                                  var SIGINT: number;

                                                                                                                                                                                                                                                                                                                                                                                                    variable SIGKILL

                                                                                                                                                                                                                                                                                                                                                                                                    var SIGKILL: number;

                                                                                                                                                                                                                                                                                                                                                                                                      variable SIGSEGV

                                                                                                                                                                                                                                                                                                                                                                                                      var SIGSEGV: number;

                                                                                                                                                                                                                                                                                                                                                                                                        variable SIGTERM

                                                                                                                                                                                                                                                                                                                                                                                                        var SIGTERM: number;

                                                                                                                                                                                                                                                                                                                                                                                                          variable SIGWINCH

                                                                                                                                                                                                                                                                                                                                                                                                          var SIGWINCH: number;

                                                                                                                                                                                                                                                                                                                                                                                                            variable SSL_OP_ALL

                                                                                                                                                                                                                                                                                                                                                                                                            var SSL_OP_ALL: number;

                                                                                                                                                                                                                                                                                                                                                                                                              variable SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION

                                                                                                                                                                                                                                                                                                                                                                                                              var SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION: number;

                                                                                                                                                                                                                                                                                                                                                                                                                variable SSL_OP_CIPHER_SERVER_PREFERENCE

                                                                                                                                                                                                                                                                                                                                                                                                                var SSL_OP_CIPHER_SERVER_PREFERENCE: number;

                                                                                                                                                                                                                                                                                                                                                                                                                  variable SSL_OP_CISCO_ANYCONNECT

                                                                                                                                                                                                                                                                                                                                                                                                                  var SSL_OP_CISCO_ANYCONNECT: number;
                                                                                                                                                                                                                                                                                                                                                                                                                    var SSL_OP_COOKIE_EXCHANGE: number;

                                                                                                                                                                                                                                                                                                                                                                                                                      variable SSL_OP_CRYPTOPRO_TLSEXT_BUG

                                                                                                                                                                                                                                                                                                                                                                                                                      var SSL_OP_CRYPTOPRO_TLSEXT_BUG: number;

                                                                                                                                                                                                                                                                                                                                                                                                                        variable SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS

                                                                                                                                                                                                                                                                                                                                                                                                                        var SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS: number;

                                                                                                                                                                                                                                                                                                                                                                                                                          variable SSL_OP_EPHEMERAL_RSA

                                                                                                                                                                                                                                                                                                                                                                                                                          var SSL_OP_EPHEMERAL_RSA: number;

                                                                                                                                                                                                                                                                                                                                                                                                                            variable SSL_OP_LEGACY_SERVER_CONNECT

                                                                                                                                                                                                                                                                                                                                                                                                                            var SSL_OP_LEGACY_SERVER_CONNECT: number;

                                                                                                                                                                                                                                                                                                                                                                                                                              variable SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER

                                                                                                                                                                                                                                                                                                                                                                                                                              var SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                variable SSL_OP_MICROSOFT_SESS_ID_BUG

                                                                                                                                                                                                                                                                                                                                                                                                                                var SSL_OP_MICROSOFT_SESS_ID_BUG: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                  variable SSL_OP_MSIE_SSLV2_RSA_PADDING

                                                                                                                                                                                                                                                                                                                                                                                                                                  var SSL_OP_MSIE_SSLV2_RSA_PADDING: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                    variable SSL_OP_NETSCAPE_CA_DN_BUG

                                                                                                                                                                                                                                                                                                                                                                                                                                    var SSL_OP_NETSCAPE_CA_DN_BUG: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                      variable SSL_OP_NETSCAPE_CHALLENGE_BUG

                                                                                                                                                                                                                                                                                                                                                                                                                                      var SSL_OP_NETSCAPE_CHALLENGE_BUG: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                        variable SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG

                                                                                                                                                                                                                                                                                                                                                                                                                                        var SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                          variable SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG

                                                                                                                                                                                                                                                                                                                                                                                                                                          var SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                            variable SSL_OP_NO_COMPRESSION

                                                                                                                                                                                                                                                                                                                                                                                                                                            var SSL_OP_NO_COMPRESSION: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                              variable SSL_OP_NO_QUERY_MTU

                                                                                                                                                                                                                                                                                                                                                                                                                                              var SSL_OP_NO_QUERY_MTU: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                variable SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION

                                                                                                                                                                                                                                                                                                                                                                                                                                                var SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  variable SSL_OP_NO_SSLv2

                                                                                                                                                                                                                                                                                                                                                                                                                                                  var SSL_OP_NO_SSLv2: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    variable SSL_OP_NO_SSLv3

                                                                                                                                                                                                                                                                                                                                                                                                                                                    var SSL_OP_NO_SSLv3: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      variable SSL_OP_NO_TICKET

                                                                                                                                                                                                                                                                                                                                                                                                                                                      var SSL_OP_NO_TICKET: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        variable SSL_OP_NO_TLSv1

                                                                                                                                                                                                                                                                                                                                                                                                                                                        var SSL_OP_NO_TLSv1: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          variable SSL_OP_NO_TLSv1_1

                                                                                                                                                                                                                                                                                                                                                                                                                                                          var SSL_OP_NO_TLSv1_1: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            variable SSL_OP_NO_TLSv1_2

                                                                                                                                                                                                                                                                                                                                                                                                                                                            var SSL_OP_NO_TLSv1_2: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              variable SSL_OP_PKCS1_CHECK_1

                                                                                                                                                                                                                                                                                                                                                                                                                                                              var SSL_OP_PKCS1_CHECK_1: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                variable SSL_OP_PKCS1_CHECK_2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                var SSL_OP_PKCS1_CHECK_2: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  variable SSL_OP_SINGLE_DH_USE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  var SSL_OP_SINGLE_DH_USE: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    variable SSL_OP_SINGLE_ECDH_USE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    var SSL_OP_SINGLE_ECDH_USE: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      variable SSL_OP_SSLEAY_080_CLIENT_DH_BUG

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      var SSL_OP_SSLEAY_080_CLIENT_DH_BUG: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        variable SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        var SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          variable SSL_OP_TLS_BLOCK_PADDING_BUG

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          var SSL_OP_TLS_BLOCK_PADDING_BUG: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            variable SSL_OP_TLS_D5_BUG

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            var SSL_OP_TLS_D5_BUG: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              variable SSL_OP_TLS_ROLLBACK_BUG

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              var SSL_OP_TLS_ROLLBACK_BUG: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                variable UV_UDP_REUSEADDR

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                var UV_UDP_REUSEADDR: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  variable W_OK

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  var W_OK: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    variable WSA_E_CANCELLED

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    var WSA_E_CANCELLED: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      variable WSA_E_NO_MORE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      var WSA_E_NO_MORE: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        variable WSAEACCES

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        var WSAEACCES: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          variable WSAEADDRINUSE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          var WSAEADDRINUSE: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            variable WSAEADDRNOTAVAIL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            var WSAEADDRNOTAVAIL: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              variable WSAEAFNOSUPPORT

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              var WSAEAFNOSUPPORT: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                variable WSAEALREADY

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                var WSAEALREADY: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  variable WSAEBADF

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  var WSAEBADF: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    variable WSAECANCELLED

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    var WSAECANCELLED: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      variable WSAECONNABORTED

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      var WSAECONNABORTED: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        variable WSAECONNREFUSED

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        var WSAECONNREFUSED: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          variable WSAECONNRESET

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          var WSAECONNRESET: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            variable WSAEDESTADDRREQ

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            var WSAEDESTADDRREQ: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              variable WSAEDISCON

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              var WSAEDISCON: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                variable WSAEDQUOT

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                var WSAEDQUOT: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  variable WSAEFAULT

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  var WSAEFAULT: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    variable WSAEHOSTDOWN

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    var WSAEHOSTDOWN: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      variable WSAEHOSTUNREACH

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      var WSAEHOSTUNREACH: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        variable WSAEINPROGRESS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        var WSAEINPROGRESS: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          variable WSAEINTR

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          var WSAEINTR: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            variable WSAEINVAL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            var WSAEINVAL: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              variable WSAEINVALIDPROCTABLE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              var WSAEINVALIDPROCTABLE: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                variable WSAEINVALIDPROVIDER

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                var WSAEINVALIDPROVIDER: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  variable WSAEISCONN

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  var WSAEISCONN: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    variable WSAELOOP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    var WSAELOOP: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      variable WSAEMFILE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      var WSAEMFILE: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        variable WSAEMSGSIZE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        var WSAEMSGSIZE: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          variable WSAENAMETOOLONG

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          var WSAENAMETOOLONG: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            variable WSAENETDOWN

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            var WSAENETDOWN: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              variable WSAENETRESET

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              var WSAENETRESET: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                variable WSAENETUNREACH

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                var WSAENETUNREACH: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  variable WSAENOBUFS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  var WSAENOBUFS: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    variable WSAENOMORE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    var WSAENOMORE: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      variable WSAENOPROTOOPT

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      var WSAENOPROTOOPT: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        variable WSAENOTCONN

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        var WSAENOTCONN: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          variable WSAENOTEMPTY

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          var WSAENOTEMPTY: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            variable WSAENOTSOCK

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            var WSAENOTSOCK: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              variable WSAEOPNOTSUPP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              var WSAEOPNOTSUPP: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                variable WSAEPFNOSUPPORT

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                var WSAEPFNOSUPPORT: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  variable WSAEPROCLIM

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  var WSAEPROCLIM: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    variable WSAEPROTONOSUPPORT

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    var WSAEPROTONOSUPPORT: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      variable WSAEPROTOTYPE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      var WSAEPROTOTYPE: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        variable WSAEPROVIDERFAILEDINIT

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        var WSAEPROVIDERFAILEDINIT: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          variable WSAEREFUSED

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          var WSAEREFUSED: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            variable WSAEREMOTE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            var WSAEREMOTE: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              variable WSAESHUTDOWN

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              var WSAESHUTDOWN: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                variable WSAESOCKTNOSUPPORT

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                var WSAESOCKTNOSUPPORT: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  variable WSAESTALE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  var WSAESTALE: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    variable WSAETIMEDOUT

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    var WSAETIMEDOUT: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      variable WSAETOOMANYREFS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      var WSAETOOMANYREFS: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        variable WSAEUSERS

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        var WSAEUSERS: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          variable WSAEWOULDBLOCK

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          var WSAEWOULDBLOCK: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            variable WSANOTINITIALISED

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            var WSANOTINITIALISED: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              variable WSASERVICE_NOT_FOUND

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              var WSASERVICE_NOT_FOUND: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                variable WSASYSCALLFAILURE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                var WSASYSCALLFAILURE: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  variable WSASYSNOTREADY

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  var WSASYSNOTREADY: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    variable WSATYPE_NOT_FOUND

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    var WSATYPE_NOT_FOUND: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      variable WSAVERNOTSUPPORTED

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      var WSAVERNOTSUPPORTED: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        variable X_OK

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        var X_OK: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          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 createDecipher

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function createDecipheriv

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      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;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (algorithm: string, key: Buffer): 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 | Buffer,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  salt: string | Buffer,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  iterations: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  keylen: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  callback: (err: Error, derivedKey: Buffer) => any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  password: string | Buffer,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  salt: string | Buffer,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  iterations: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  keylen: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  digest: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  callback: (err: Error, derivedKey: Buffer) => any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function pbkdf2Sync

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function pseudoRandomBytes

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function randomBytes

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface Cipher

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface Cipher {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method final

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method setAutoPadding

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              setAutoPadding: (auto_padding: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method update

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CredentialDetails

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CredentialDetails {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property ca

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ca: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property cert

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      cert: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property ciphers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ciphers: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property crl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          crl: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property key

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            key: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property passphrase

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              passphrase: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property pfx

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                pfx: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface Credentials

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface Credentials {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property context

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    context?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface Decipher

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface Decipher {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method final

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method setAutoPadding

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          setAutoPadding: (auto_padding: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method update

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface DiffieHellman

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface DiffieHellman {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method computeSecret

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  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: 'buffer'): Buffer; (encoding: string): any; (): Buffer };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method update

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface Hmac

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface Hmac {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method digest

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method update

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface Signer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface Signer extends NodeJS.WritableStream {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method sign

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method update

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                update: (data: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface Verify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface Verify extends NodeJS.WritableStream {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    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?: (msg: Buffer, rinfo: RemoteInfo) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Socket;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface AddressInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface AddressInfo {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property address

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              address: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property family

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                family: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property port

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  port: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface RemoteInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface RemoteInfo {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property address

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      address: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property port

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        port: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property size

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          size: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface Socket

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface Socket extends events.EventEmitter {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method addMembership

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method address

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                address: () => AddressInfo;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method bind

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    close: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method dropMembership

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method send

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          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: events.EventEmitter) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method addListener

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method bind

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method dispose

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  dispose: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method intercept

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method on

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method once

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method remove

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method removeAllListeners

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method removeListener

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method run

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                run: (fn: Function) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  namespace es6-collections

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  module 'es6-collections' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    variable Map

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    var Map: MapConstructor;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      variable Set

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      var Set: SetConstructor;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        variable WeakMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        var WeakMap: WeakMapConstructor;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          variable WeakSet

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          var WeakSet: WeakSetConstructor;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            namespace es6-promise

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            module 'es6-promise' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              variable Promise

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              var Promise: PromiseConstructor;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                namespace events

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                module 'events' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class EventEmitter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class EventEmitter implements NodeJS.EventEmitter {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property defaultMaxListeners

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    static defaultMaxListeners: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property EventEmitter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      static EventEmitter: EventEmitter;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method addListener

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method emit

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getMaxListeners

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getMaxListeners: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              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) => EventEmitter;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            namespace fs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            module 'fs' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              variable F_OK

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              var F_OK: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Constant for fs.access(). File is visible to the calling process.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              variable R_OK

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              var R_OK: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Constant for fs.access(). File can be read by the calling process.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              variable W_OK

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              var W_OK: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Constant for fs.access(). File can be written by the calling process.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              variable X_OK

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              var X_OK: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Constant for fs.access(). File can be executed by the calling process.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function access

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              access: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (path: string, callback: (err: NodeJS.ErrnoException) => void): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              path: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              mode: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              callback: (err: NodeJS.ErrnoException) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Tests a user's permissions for the file specified by path.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function accessSync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              accessSync: (path: string, mode?: number) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Synchronous version of fs.access. This throws if any accessibility checks fail, and does nothing otherwise.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function appendFile

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                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?: NodeJS.ErrnoException) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  path: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  mode: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  callback?: (err?: NodeJS.ErrnoException) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function chmodSync

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function chown

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function chownSync

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function close

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function closeSync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            closeSync: (fd: number) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function createReadStream

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              createReadStream: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              path: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              options?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              flags?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              encoding?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              fd?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              mode?: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              autoClose?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => ReadStream;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function createWriteStream

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                createWriteStream: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                path: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                options?: { flags?: string; encoding?: string; fd?: number; mode?: number }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => 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?: NodeJS.ErrnoException) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      fd: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      mode: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      callback?: (err?: NodeJS.ErrnoException) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function fchmodSync

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function fchown

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function fchownSync

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function fstat

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function fstatSync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                fstatSync: (fd: number) => Stats;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function fsync

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function fsyncSync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    fsyncSync: (fd: number) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function ftruncate

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function ftruncateSync

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function futimes

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function futimesSync

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function lchmod

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function lchmodSync

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function lchown

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function lchownSync

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function linkSync

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function lstat

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function lstatSync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            lstatSync: (path: string) => Stats;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function mkdir

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function mkdirSync

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function open

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function openSync

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function read

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function readdir

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function readdirSync

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function readFile

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function readFileSync

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function readlinkSync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readlinkSync: (path: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function readSync

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function realpath

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function realpathSync

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function rename

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter oldPath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter newPath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter callback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            No arguments other than a possible exception are given to the completion callback.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function renameSync

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter oldPath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter newPath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function rmdir

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function rmdirSync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            rmdirSync: (path: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function stat

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function statSync

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function symlinkSync

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function truncate

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function truncateSync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        truncateSync: (path: string, len?: number) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          unlink: (path: string, callback?: (err?: NodeJS.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?: NodeJS.ErrnoException) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                path: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                atime: Date,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                mtime: Date,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                callback?: (err?: NodeJS.ErrnoException) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function utimesSync

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    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: Buffer,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        offset: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        length: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        position: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        callback?: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        err: NodeJS.ErrnoException,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        written: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        buffer: Buffer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        fd: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        buffer: Buffer,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        offset: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        length: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        callback?: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        err: NodeJS.ErrnoException,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        written: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        buffer: Buffer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        fd: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        data: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        callback?: (err: NodeJS.ErrnoException, written: number, str: string) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        fd: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        data: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        offset: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        callback?: (err: NodeJS.ErrnoException, written: number, str: string) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        fd: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        data: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        offset: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        encoding: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        callback?: (err: NodeJS.ErrnoException, written: number, str: string) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function writeFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          writeFile: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          filename: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          data: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          callback?: (err: <