anchor.diff:      abstract writeFloatBE: value: float * offset: float * ?noAssert: bool -> float
       abstract writeDoubleLE: value: float * offset: float * ?noAssert: bool -> float
       abstract writeDoubleBE: value: float * offset: float * ?noAssert: bool -> float
  -    abstract fill: value: obj * ?offset: float * ?``end``: float -> Buffer
  -
  +    abstract fill: value: obj * ?offset: float * ?``end``: float -> obj
  +    abstract indexOf: value: U3<string, float, Buffer> * ?byteOffset: float * ?encoding: string -> float
  +    abstract lastIndexOf: value: U3<string, float, Buffer> * ?byteOffset: float * ?encoding: string -> float
  +    abstract entries: unit -> IterableIterator<float * float>
  +    abstract includes: value: U3<string, float, Buffer> * ?byteOffset: float * ?encoding: string -> bool
  +    abstract keys: unit -> IterableIterator<float>
  +    abstract values: unit -> IterableIterator<float>
   
   module NodeJS =
       type [<AllowNullLiteral>] ErrnoException =
  
positive.code: 
  let [<Import("*","tls")>] tls: tls_types.Globals = jsNative
  
  
  module child_process_types =
      type [<AllowNullLiteral>] ChildProcess =
          inherit EventEmitter
          abstract stdin: stream.Writable with get, set
          abstract stdout: stream.Readable with get, set
          abstract stderr: stream.Readable with get, set
          abstract stdio: U2<stream.Readable,stream.Writable>[] with get, set
          abstract pid: float with get, set
          abstract kill: ?signal: string -> unit
          abstract send: message: obj * ?sendHandle: obj -> unit
          abstract disconnect: unit -> unit
          abstract unref: unit -> unit
  
      type Globals =
          member __.spawn(command: string, ?args: ResizeArray<string>, ?options: obj): ChildProcess = jsNative
          member __.exec(command: string, options: obj, ?callback: Func<Error option, Buffer, Buffer, unit>): ChildProcess = jsNative
          member __.exec(command: string, ?callback: Func<Error option, Buffer, Buffer, unit>): ChildProcess = jsNative
          member __.execFile(file: string, ?callback: Func<Error, Buffer, Buffer, unit>): ChildProcess = jsNative
          member __.execFile(file: string, ?args: ResizeArray<string>, ?callback: Func<Error, Buffer, Buffer, unit>): ChildProcess = jsNative
          member __.execFile(file: string, ?args: ResizeArray<string>, ?options: obj, ?callback: Func<Error, Buffer, Buffer, unit>): ChildProcess = jsNative
          member __.fork(modulePath: string, ?args: ResizeArray<string>, ?options: obj): ChildProcess = jsNative
          member __.spawnSync(command: string, ?args: ResizeArray<string>, ?options: obj): obj = jsNative
          member __.execSync(command: string, ?options: obj): U2<string, Buffer> = jsNative
          member __.execFileSync(command: string, ?args: ResizeArray<string>, ?options: obj): U2<string, Buffer> = jsNative
  
  let [<Import("*","child_process")>] child_process: child_process_types.Globals = jsNative
  
  
  type [<AllowNullLiteral>] NodeRequireFunction =
      [<Emit("$0($1...)")>] abstract Invoke: id: string -> obj
  
  and [<AllowNullLiteral>] NodeRequire =
      inherit NodeRequireFunction
      abstract cache: obj with get, set
      abstract extensions: obj with get, set
      abstract main: obj with get, set
      abstract resolve: id: string -> string
  
  and [<AllowNullLiteral>] NodeModule =
      abstract exports: obj with get, set
      abstract require: NodeRequireFunction with get, set
      abstract id: string with get, set
      abstract filename: string with get, set
      abstract loaded: bool with get, set
      abstract parent: obj with get, set
      abstract children: ResizeArray<obj> with get, set
  
  let [<Global>] ``process``: NodeJS.Process = jsNative
  let [<Global>] ``global``: NodeJS.Global = jsNative
  let [<Global>] __filename: string = jsNative
  let [<Global>] __dirname: string = jsNative
  let [<Global>] require: NodeRequire = jsNative
  let [<Global>] ``module``: NodeModule = jsNative
  let [<Global>] exports: obj = jsNative
  let [<Global>] SlowBuffer: obj = jsNative
  let [<Global>] Buffer: obj = jsNative
  
  
  module buffer_types =
      type Globals =
          member __.INSPECT_MAX_BYTES with get(): float = jsNative and set(v: float): unit = jsNative
  
  let [<Import("*","buffer")>] buffer: buffer_types.Globals = jsNative
  
  
  module querystring_types =
      type Globals =
          member __.stringify(obj: obj, ?sep: string, ?eq: string): string = jsNative
          member __.parse(str: string, ?sep: string, ?eq: string, ?options: obj): obj = jsNative
          member __.escape(str: string): string = jsNative
          member __.unescape(str: string): string = jsNative
  
  let [<Import("*","querystring")>] querystring: querystring_types.Globals = jsNative
  
  
  module http_types =
      type [<AllowNullLiteral>] Server =
          abstract listenerCount: emitter: EventEmitter * ``event``: string -> float
          abstract maxHeadersCount: float with get, set
          abstract listen: port: float * ?hostname: string * ?backlog: float * ?callback: Function -> Server
          abstract listen: port: float * ?hostname: string * ?callback: Function -> Server
          abstract listen: path: string * ?callback: Function -> Server
          abstract listen: handle: obj * ?listeningListener: Function -> Server
          abstract close: ?cb: obj -> Server
          abstract address: unit -> obj
  
      and [<AllowNullLiteral>] ServerRequest =
          inherit IncomingMessage
          abstract connection: net_types.Socket with get, set
  
      and [<AllowNullLiteral>] ServerResponse =
          abstract listenerCount: emitter: EventEmitter * ``event``: string -> float
          abstract writable: bool with get, set
          abstract _write: chunk: obj * encoding: string * callback: Function -> unit
          abstract write: chunk: obj * ?cb: Function -> bool
          abstract write: chunk: obj * ?encoding: string * ?cb: Function -> bool
          abstract ``end``: unit -> unit
          abstract ``end``: chunk: obj * ?cb: Function -> unit
          abstract ``end``: chunk: obj * ?encoding: string * ?cb: Function -> unit
          abstract statusCode: float with get, set
          abstract statusMessage: string with get, set
          abstract sendDate: bool with get, set
          abstract write: buffer: Buffer -> bool
          abstract write: buffer: Buffer * ?cb: Function -> bool
          abstract write: str: string * ?cb: Function -> bool
          abstract write: str: string * ?encoding: string * ?cb: Function -> bool
          abstract write: str: string * ?encoding: string * ?fd: string -> bool
          abstract writeContinue: unit -> unit
          abstract writeHead: statusCode: float * ?reasonPhrase: string * ?headers: obj -> unit
          abstract writeHead: statusCode: float * ?headers: obj -> unit
          abstract setHeader: name: string * value: string -> unit
          abstract getHeader: name: string -> string
          abstract removeHeader: name: string -> unit
          abstract write: chunk: obj * ?encoding: string -> obj
          abstract addTrailers: headers: obj -> unit
          abstract ``end``: buffer: Buffer * ?cb: Function -> unit
          abstract ``end``: str: string * ?cb: Function -> unit
          abstract ``end``: str: string * ?encoding: string * ?cb: Function -> unit
          abstract ``end``: ?data: obj * ?encoding: string -> unit
  
      and [<AllowNullLiteral>] ClientRequest =
          abstract listenerCount: emitter: EventEmitter * ``event``: string -> float
          abstract writable: bool with get, set
          abstract _write: chunk: obj * encoding: string * callback: Function -> unit
          abstract write: chunk: obj * ?cb: Function -> bool
          abstract write: chunk: obj * ?encoding: string * ?cb: Function -> bool
          abstract ``end``: unit -> unit
          abstract ``end``: chunk: obj * ?cb: Function -> unit
          abstract ``end``: chunk: obj * ?encoding: string * ?cb: Function -> unit
          abstract write: buffer: Buffer -> bool
          abstract write: buffer: Buffer * ?cb: Function -> bool
          abstract write: str: string * ?cb: Function -> bool
          abstract write: str: string * ?encoding: string * ?cb: Function -> bool
          abstract write: str: string * ?encoding: string * ?fd: string -> bool
          abstract write: chunk: obj * ?encoding: string -> unit
          abstract abort: unit -> unit
          abstract setTimeout: timeout: float * ?callback: Function -> unit
          abstract setNoDelay: ?noDelay: bool -> unit
          abstract setSocketKeepAlive: ?enable: bool * ?initialDelay: float -> unit
          abstract ``end``: buffer: Buffer * ?cb: Function -> unit
          abstract ``end``: str: string * ?cb: Function -> unit
          abstract ``end``: str: string * ?encoding: string * ?cb: Function -> unit
          abstract ``end``: ?data: obj * ?encoding: string -> unit
  
      and [<AllowNullLiteral>] IncomingMessage =
          abstract listenerCount: emitter: EventEmitter * ``event``: string -> float
          abstract readable: bool with get, set
          abstract _read: size: float -> unit
          abstract read: ?size: float -> obj
          abstract setEncoding: encoding: string -> unit
          abstract pause: unit -> unit
          abstract resume: unit -> unit
          abstract pipe: destination: 'T * ?options: obj -> 'T
          abstract unpipe: ?destination: 'T -> unit
          abstract unshift: chunk: obj -> unit
          abstract wrap: oldStream: NodeJS.ReadableStream -> NodeJS.ReadableStream
          abstract push: chunk: obj * ?encoding: string -> bool
          abstract httpVersion: string with get, set
          abstract headers: obj with get, set
          abstract rawHeaders: ResizeArray<string> with get, set
          abstract trailers: obj with get, set
          abstract rawTrailers: obj with get, set
          abstract ``method``: string option with get, set
          abstract url: string option with get, set
          abstract statusCode: float option with get, set
          abstract statusMessage: string option with get, set
          abstract socket: net_types.Socket with get, set
          abstract setTimeout: msecs: float * callback: Function -> NodeJS.Timer
  
      and [<AllowNullLiteral>] ClientResponse =
          inherit IncomingMessage
  
      and [<AllowNullLiteral>] AgentOptions =
          abstract keepAlive: bool option with get, set
          abstract keepAliveMsecs: float option with get, set
          abstract maxSockets: float option with get, set
          abstract maxFreeSockets: float option with get, set
  
      and [<AllowNullLiteral>] [<Import("Agent","http")>] Agent(?opts: AgentOptions) =
          member __.maxSockets with get(): float = jsNative and set(v: float): unit = jsNative
          member __.sockets with get(): obj = jsNative and set(v: obj): unit = jsNative
          member __.requests with get(): obj = jsNative and set(v: obj): unit = jsNative
          member __.destroy(): unit = jsNative
  
      type Globals =
          member __.METHODS with get(): ResizeArray<string> = jsNative and set(v: ResizeArray<string>): unit = jsNative
          member __.STATUS_CODES with get(): obj = jsNative and set(v: obj): unit = jsNative
          member __.globalAgent with get(): Agent = jsNative and set(v: Agent): unit = jsNative
          member __.createServer(?requestListener: Func<IncomingMessage, ServerResponse, unit>): Server = jsNative
          member __.createClient(?port: float, ?host: string): obj = jsNative
          member __.request(options: obj, ?callback: Func<IncomingMessage, unit>): ClientRequest = jsNative
          member __.get(options: obj, ?callback: Func<IncomingMessage, unit>): ClientRequest = jsNative
  
  let [<Import("*","http")>] http: http_types.Globals = jsNative
  
  module cluster_types =
      type [<AllowNullLiteral>] ClusterSettings =
          abstract exec: string option with get, set
          abstract args: ResizeArray<string> option with get, set
          abstract silent: bool option with get, set
  
      and [<AllowNullLiteral>] [<Import("Worker","cluster")>] Worker() =
          inherit events.EventEmitter()
          member __.id with get(): string = jsNative and set(v: string): unit = jsNative
          member __.``process`` with get(): child_process_types.ChildProcess = jsNative and set(v: child_process_types.ChildProcess): unit = jsNative
          member __.suicide with get(): bool = jsNative and set(v: bool): unit = jsNative
          member __.send(message: obj, ?sendHandle: obj): unit = jsNative
          member __.kill(?signal: string): unit = jsNative
          member __.destroy(?signal: string): unit = jsNative
          member __.disconnect(): unit = jsNative
  
      type Globals =
          member __.settings with get(): ClusterSettings = jsNative and set(v: ClusterSettings): unit = jsNative
          member __.isMaster with get(): bool = jsNative and set(v: bool): unit = jsNative
          member __.isWorker with get(): bool = jsNative and set(v: bool): unit = jsNative
          member __.worker with get(): Worker = jsNative and set(v: Worker): unit = jsNative
          member __.workers with get(): ResizeArray<Worker> = jsNative and set(v: ResizeArray<Worker>): unit = jsNative
          member __.setupMaster(?settings: ClusterSettings): unit = jsNative
          member __.fork(?env: obj): Worker = jsNative
          member __.disconnect(?callback: Function): unit = jsNative
          member __.addListener(``event``: string, listener: Function): unit = jsNative
          member __.on(``event``: string, listener: Function): obj = jsNative
          member __.once(``event``: string, listener: Function): unit = jsNative
          member __.removeListener(``event``: string, listener: Function): unit = jsNative
          member __.removeAllListeners(?``event``: string): unit = jsNative
          member __.setMaxListeners(n: float): unit = jsNative
          member __.listeners(``event``: string): ResizeArray<Function> = jsNative
          member __.emit(``event``: string, [<ParamArray>] args: obj[]): bool = jsNative
  
  let [<Import("*","cluster")>] cluster: cluster_types.Globals = jsNative
  
  
  module zlib_types =
      type [<AllowNullLiteral>] ZlibOptions =
          abstract chunkSize: float option with get, set
          abstract windowBits: float option with get, set
          abstract level: float option with get, set
          abstract memLevel: float option with get, set
          abstract strategy: float option with get, set
          abstract dictionary: obj option with get, set
  
      and [<AllowNullLiteral>] Gzip =
          abstract readable: bool with get, set
          abstract writable: bool with get, set
          abstract _transform: chunk: obj * encoding: string * callback: Function -> unit
          abstract _flush: callback: Function -> unit
          abstract read: ?size: float -> obj
          abstract setEncoding: encoding: string -> unit
          abstract pause: unit -> unit
          abstract resume: unit -> unit
          abstract pipe: destination: 'T * ?options: obj -> 'T
          abstract unpipe: ?destination: 'T -> unit
          abstract unshift: chunk: obj -> unit
          abstract wrap: oldStream: NodeJS.ReadableStream -> NodeJS.ReadableStream
          abstract push: chunk: obj * ?encoding: string -> bool
          abstract write: chunk: obj * ?cb: Function -> bool
          abstract write: chunk: obj * ?encoding: string * ?cb: Function -> bool
          abstract ``end``: unit -> unit
          abstract ``end``: chunk: obj * ?cb: Function -> unit
          abstract ``end``: chunk: obj * ?encoding: string * ?cb: Function -> unit
  
  
      and [<AllowNullLiteral>] Gunzip =
          abstract readable: bool with get, set
          abstract writable: bool with get, set
          abstract _transform: chunk: obj * encoding: string * callback: Function -> unit
          abstract _flush: callback: Function -> unit
          abstract read: ?size: float -> obj
          abstract setEncoding: encoding: string -> unit
          abstract pause: unit -> unit
          abstract resume: unit -> unit
          abstract pipe: destination: 'T * ?options: obj -> 'T
          abstract unpipe: ?destination: 'T -> unit
          abstract unshift: chunk: obj -> unit
          abstract wrap: oldStream: NodeJS.ReadableStream -> NodeJS.ReadableStream
          abstract push: chunk: obj * ?encoding: string -> bool
          abstract write: chunk: obj * ?cb: Function -> bool
          abstract write: chunk: obj * ?encoding: string * ?cb: Function -> bool
          abstract ``end``: unit -> unit
          abstract ``end``: chunk: obj * ?cb: Function -> unit
          abstract ``end``: chunk: obj * ?encoding: string * ?cb: Function -> unit
  
  
      and [<AllowNullLiteral>] Deflate =
          abstract readable: bool with get, set
          abstract writable: bool with get, set
          abstract _transform: chunk: obj * encoding: string * callback: Function -> unit
          abstract _flush: callback: Function -> unit
          abstract read: ?size: float -> obj
          abstract setEncoding: encoding: string -> unit
          abstract pause: unit -> unit
          abstract resume: unit -> unit
          abstract pipe: destination: 'T * ?options: obj -> 'T
          abstract unpipe: ?destination: 'T -> unit
          abstract unshift: chunk: obj -> unit
          abstract wrap: oldStream: NodeJS.ReadableStream -> NodeJS.ReadableStream
          abstract push: chunk: obj * ?encoding: string -> bool
          abstract write: chunk: obj * ?cb: Function -> bool
          abstract write: chunk: obj * ?encoding: string * ?cb: Function -> bool
          abstract ``end``: unit -> unit
          abstract ``end``: chunk: obj * ?cb: Function -> unit
          abstract ``end``: chunk: obj * ?encoding: string * ?cb: Function -> unit
  
  
      and [<AllowNullLiteral>] Inflate =
          abstract readable: bool with get, set
          abstract writable: bool with get, set
          abstract _transform: chunk: obj * encoding: string * callback: Function -> unit
          abstract _flush: callback: Function -> unit
          abstract read: ?size: float -> obj
          abstract setEncoding: encoding: string -> unit
          abstract pause: unit -> unit
          abstract resume: unit -> unit
          abstract pipe: destination: 'T * ?options: obj -> 'T
          abstract unpipe: ?destination: 'T -> unit
          abstract unshift: chunk: obj -> unit
          abstract wrap: oldStream: NodeJS.ReadableStream -> NodeJS.ReadableStream
          abstract push: chunk: obj * ?encoding: string -> bool
          abstract write: chunk: obj * ?cb: Function -> bool
          abstract write: chunk: obj * ?encoding: string * ?cb: Function -> bool
          abstract ``end``: unit -> unit
          abstract ``end``: chunk: obj * ?cb: Function -> unit
          abstract ``end``: chunk: obj * ?encoding: string * ?cb: Function -> unit
  
  
      and [<AllowNullLiteral>] DeflateRaw =
          abstract readable: bool with get, set
          abstract writable: bool with get, set
          abstract _transform: chunk: obj * encoding: string * callback: Function -> unit
          abstract _flush: callback: Function -> unit
          abstract read: ?size: float -> obj
          abstract setEncoding: encoding: string -> unit
          abstract pause: unit -> unit
          abstract resume: unit -> unit
          abstract pipe: destination: 'T * ?options: obj -> 'T
          abstract unpipe: ?destination: 'T -> unit
          abstract unshift: chunk: obj -> unit
          abstract wrap: oldStream: NodeJS.ReadableStream -> NodeJS.ReadableStream
          abstract push: chunk: obj * ?encoding: string -> bool
          abstract write: chunk: obj * ?cb: Function -> bool
          abstract write: chunk: obj * ?encoding: string * ?cb: Function -> bool
          abstract ``end``: unit -> unit
          abstract ``end``: chunk: obj * ?cb: Function -> unit
          abstract ``end``: chunk: obj * ?encoding: string * ?cb: Function -> unit
  
  
      and [<AllowNullLiteral>] InflateRaw =
          abstract readable: bool with get, set
          abstract writable: bool with get, set
          abstract _transform: chunk: obj * encoding: string * callback: Function -> unit
          abstract _flush: callback: Function -> unit
          abstract read: ?size: float -> obj
          abstract setEncoding: encoding: string -> unit
          abstract pause: unit -> unit
          abstract resume: unit -> unit
          abstract pipe: destination: 'T * ?options: obj -> 'T
          abstract unpipe: ?destination: 'T -> unit
          abstract unshift: chunk: obj -> unit
          abstract wrap: oldStream: NodeJS.ReadableStream -> NodeJS.ReadableStream
          abstract push: chunk: obj * ?encoding: string -> bool
          abstract write: chunk: obj * ?cb: Function -> bool
          abstract write: chunk: obj * ?encoding: string * ?cb: Function -> bool
          abstract ``end``: unit -> unit
          abstract ``end``: chunk: obj * ?cb: Function -> unit
          abstract ``end``: chunk: obj * ?encoding: string * ?cb: Function -> unit
  
  
      and [<AllowNullLiteral>] Unzip =
          abstract readable: bool with get, set
          abstract writable: bool with get, set
          abstract _transform: chunk: obj * encoding: string * callback: Function -> unit
          abstract _flush: callback: Function -> unit
          abstract read: ?size: float -> obj
          abstract setEncoding: encoding: string -> unit
          abstract pause: unit -> unit
          abstract resume: unit -> unit
          abstract pipe: destination: 'T * ?options: obj -> 'T
          abstract unpipe: ?destination: 'T -> unit
          abstract unshift: chunk: obj -> unit
          abstract wrap: oldStream: NodeJS.ReadableStream -> NodeJS.ReadableStream
          abstract push: chunk: obj * ?encoding: string -> bool
          abstract write: chunk: obj * ?cb: Function -> bool
          abstract write: chunk: obj * ?encoding: string * ?cb: Function -> bool
          abstract ``end``: unit -> unit
          abstract ``end``: chunk: obj * ?cb: Function -> unit
          abstract ``end``: chunk: obj * ?encoding: string * ?cb: Function -> unit
  
  
      type Globals =
          member __.Z_NO_FLUSH with get(): float = jsNative and set(v: float): unit = jsNative
          member __.Z_PARTIAL_FLUSH with get(): float = jsNative and set(v: float): unit = jsNative
          member __.Z_SYNC_FLUSH with get(): float = jsNative and set(v: float): unit = jsNative
          member __.Z_FULL_FLUSH with get(): float = jsNative and set(v: float): unit = jsNative
          member __.Z_FINISH with get(): float = jsNative and set(v: float): unit = jsNative
          member __.Z_BLOCK with get(): float = jsNative and set(v: float): unit = jsNative
          member __.Z_TREES with get(): float = jsNative and set(v: float): unit = jsNative
          member __.Z_OK with get(): float = jsNative and set(v: float): unit = jsNative
          member __.Z_STREAM_END with get(): float = jsNative and set(v: float): unit = jsNative
          member __.Z_NEED_DICT with get(): float = jsNative and set(v: float): unit = jsNative
          member __.Z_ERRNO with get(): float = jsNative and set(v: float): unit = jsNative
          member __.Z_STREAM_ERROR with get(): float = jsNative and set(v: float): unit = jsNative
          member __.Z_DATA_ERROR with get(): float = jsNative and set(v: float): unit = jsNative
          member __.Z_MEM_ERROR with get(): float = jsNative and set(v: float): unit = jsNative
          member __.Z_BUF_ERROR with get(): float = jsNative and set(v: float): unit = jsNative
          member __.Z_VERSION_ERROR with get(): float = jsNative and set(v: float): unit = jsNative
          member __.Z_NO_COMPRESSION with get(): float = jsNative and set(v: float): unit = jsNative
          member __.Z_BEST_SPEED with get(): float = jsNative and set(v: float): unit = jsNative
          member __.Z_BEST_COMPRESSION with get(): float = jsNative and set(v: float): unit = jsNative
          member __.Z_DEFAULT_COMPRESSION with get(): float = jsNative and set(v: float): unit = jsNative
          member __.Z_FILTERED with get(): float = jsNative and set(v: float): unit = jsNative
          member __.Z_HUFFMAN_ONLY with get(): float = jsNative and set(v: float): unit = jsNative
          member __.Z_RLE with get(): float = jsNative and set(v: float): unit = jsNative
          member __.Z_FIXED with get(): float = jsNative and set(v: float): unit = jsNative
          member __.Z_DEFAULT_STRATEGY with get(): float = jsNative and set(v: float): unit = jsNative
          member __.Z_BINARY with get(): float = jsNative and set(v: float): unit = jsNative
          member __.Z_TEXT with get(): float = jsNative and set(v: float): unit = jsNative
          member __.Z_ASCII with get(): float = jsNative and set(v: float): unit = jsNative
          member __.Z_UNKNOWN with get(): float = jsNative and set(v: float): unit = jsNative
          member __.Z_DEFLATED with get(): float = jsNative and set(v: float): unit = jsNative
          member __.Z_NULL with get(): float = jsNative and set(v: float): unit = jsNative
          member __.createGzip(?options: ZlibOptions): Gzip = jsNative
          member __.createGunzip(?options: ZlibOptions): Gunzip = jsNative
          member __.createDeflate(?options: ZlibOptions): Deflate = jsNative
          member __.createInflate(?options: ZlibOptions): Inflate = jsNative
          member __.createDeflateRaw(?options: ZlibOptions): DeflateRaw = jsNative
          member __.createInflateRaw(?options: ZlibOptions): InflateRaw = jsNative
          member __.createUnzip(?options: ZlibOptions): Unzip = jsNative
          member __.deflate(buf: Buffer, callback: Func<Error, obj, unit>): unit = jsNative
          member __.deflateSync(buf: Buffer, ?options: ZlibOptions): obj = jsNative
          member __.deflateRaw(buf: Buffer, callback: Func<Error, obj, unit>): unit = jsNative
          member __.deflateRawSync(buf: Buffer, ?options: ZlibOptions): obj = jsNative
          member __.gzip(buf: Buffer, callback: Func<Error, obj, unit>): unit = jsNative
          member __.gzipSync(buf: Buffer, ?options: ZlibOptions): obj = jsNative
          member __.gunzip(buf: Buffer, callback: Func<Error, obj, unit>): unit = jsNative
          member __.gunzipSync(buf: Buffer, ?options: ZlibOptions): obj = jsNative
          member __.inflate(buf: Buffer, callback: Func<Error, obj, unit>): unit = jsNative
          member __.inflateSync(buf: Buffer, ?options: ZlibOptions): obj = jsNative
          member __.inflateRaw(buf: Buffer, callback: Func<Error, obj, unit>): unit = jsNative
          member __.inflateRawSync(buf: Buffer, ?options: ZlibOptions): obj = jsNative
          member __.unzip(buf: Buffer, callback: Func<Error, obj, unit>): unit = jsNative
          member __.unzipSync(buf: Buffer, ?options: ZlibOptions): obj = jsNative
  
  let [<Import("*","zlib")>] zlib: zlib_types.Globals = jsNative
  
  
  module os_types =
      type Globals =
          member __.EOL with get(): string = jsNative and set(v: string): unit = jsNative
          member __.tmpdir(): string = jsNative
          member __.hostname(): string = jsNative
          member __.``type``(): string = jsNative
          member __.platform(): string = jsNative
          member __.arch(): string = jsNative
          member __.release(): string = jsNative
          member __.uptime(): float = jsNative
          member __.loadavg(): ResizeArray<float> = jsNative
          member __.totalmem(): float = jsNative
          member __.freemem(): float = jsNative
          member __.cpus(): ResizeArray<obj> = jsNative
          member __.networkInterfaces(): obj = jsNative
  
  let [<Import("*","os")>] os: os_types.Globals = jsNative
  
  
  module https_types =
      type [<AllowNullLiteral>] ServerOptions =
          abstract pfx: obj option with get, set
          abstract key: obj option with get, set
  
negative.code:         abstract getuid: unit -> float
          abstract setuid: id: float -> unit
          abstract setuid: id: string -> unit
          abstract kill: pid: float * ?signal: U2<string, float> -> unit
          abstract memoryUsage: unit -> MemoryUsage
          abstract cpuUsage: ?previousValue: CpuUsage -> CpuUsage
          abstract nextTick: callback: Function * [<ParamArray>] args: obj[] -> unit
          abstract umask: ?mask: float -> float
          abstract uptime: unit -> float
          abstract hrtime: ?time: float * float -> float * float
          abstract send: message: obj * ?sendHandle: obj -> unit
          abstract disconnect: unit -> unit
  
      and [<AllowNullLiteral>] Global =
          abstract Array: obj with get, set
  