docs: function Struct () {
    debug('defining new struct "type"')
  
    /**
     * This is the "constructor" of the Struct type that gets returned.
     *
     * Invoke it with `new` to create a new Buffer instance backing the struct.
     * Pass it an existing Buffer instance to use that as the backing buffer.
     * Pass in an Object containing the struct fields to auto-populate the
     * struct with the data.
     */
  
    function StructType (arg, data) {
      if (!(this instanceof StructType)) {
        return new StructType(arg, data)
      }
      debug('creating new struct instance')
      var store
      if (Buffer.isBuffer(arg)) {
        debug('using passed-in Buffer instance to back the struct', arg)
        assert(arg.length >= StructType.size, 'Buffer instance must be at least ' +
            StructType.size + ' bytes to back this struct type')
        store = arg
        arg = data
      } else {
        debug('creating new Buffer instance to back the struct (size: %d)', StructType.size)
        store = new Buffer(StructType.size)
      }
  
      // set the backing Buffer store
      store.type = StructType
      this['ref.buffer'] = store
  
      if (arg) {
        for (var key in arg) {
          // hopefully hit the struct setters
          this[key] = arg[key]
        }
      }
      StructType._instanceCreated = true
    }
  
    // make instances inherit from the `proto`
    StructType.prototype = Object.create(proto, {
      constructor: {
          value: StructType
        , enumerable: false
        , writable: true
        , configurable: true
      }
    })
  
    StructType.defineProperty = defineProperty
    StructType.toString = toString
    StructType.fields = {}
  
    var opt = (arguments.length > 0 && arguments[1]) ? arguments[1] : {};
    // Setup the ref "type" interface. The constructor doubles as the "type" object
    StructType.size = 0
    StructType.alignment = 0
    StructType.indirection = 1
    StructType.isPacked = opt.packed ? Boolean(opt.packed) : false
    StructType.get = get
    StructType.set = set
  
    // Read the fields list and apply all the fields to the struct
    // TODO: Better arg handling... (maybe look at ES6 binary data API?)
    var arg = arguments[0]
    if (Array.isArray(arg)) {
      // legacy API
      arg.forEach(function (a) {
        var type = a[0]
        var name = a[1]
        StructType.defineProperty(name, type)
      })
    } else if (typeof arg === 'object') {
      Object.keys(arg).forEach(function (name) {
        var type = arg[name]
        StructType.defineProperty(name, type)
      })
    }
  
    return StructType
  }