Module Node

type node_exports

type node_exports;

type node_module =
  < id : string
    ; exports : node_exports
    ; parent : node_module Js.nullable
    ; filename : string
    ; loaded : bool
    ; children : node_module array
    ; paths : string array >
    Js.t

type node_module =
  Js.t({. id: string
    , exports: node_exports
    , parent: Js.nullable(node_module)
    , filename: string
    , loaded: bool
    , children: array(node_module)
    , paths: array(string)});

type node_require =
  < main : node_module Js.undefined
    ; resolve : (string -> string) Js.Fn.arity1 >
    Js.t

type node_require =
  Js.t({. main: Js.undefined(node_module)
    , resolve: Js.Fn.arity1((string => string))});

type string_buffer

type string_buffer;

type buffer

type buffer;

type _ string_buffer_kind =

type string_buffer_kind(_) =

| String : string string_buffer_kind

| String : string_buffer_kind(string)

| Buffer : buffer string_buffer_kind

| Buffer : string_buffer_kind(buffer)

;

val test : string_buffer -> 't string_buffer_kind * 't

let test: string_buffer => (string_buffer_kind('t), 't);

We expect a good inliner will eliminate such boxing in the future

module Path : sig ... end

module Path: { ... };

Node Path API

module Fs : sig ... end

module Fs: { ... };

Node FS API

module Process : sig ... end

module Process: { ... };

module Module : sig ... end

module Module: { ... };

Node Module API

module Buffer : sig ... end

module Buffer: { ... };

Node Buffer API

module Child_process : sig ... end

module Child_process: { ... };

Node Child Process API