code: function(type, resolvedType, isMapKey, syntax) {
  
              /**
               * Element type, as a string (e.g., int32).
               * @type {{name: string, wireType: number}}
               */
              this.type = type;
  
              /**
               * Element type reference to submessage or enum definition, if needed.
               * @type {ProtoBuf.Reflect.T|null}
               */
              this.resolvedType = resolvedType;
  
              /**
               * Element is a map key.
               * @type {boolean}
               */
              this.isMapKey = isMapKey;
  
              /**
               * Syntax level of defining message type, e.g., proto2 or proto3.
               * @type {string}
               */
              this.syntax = syntax;
  
              if (isMapKey && ProtoBuf.MAP_KEY_TYPES.indexOf(type) < 0)
                  throw Error("Invalid map key type: " + type.name);
          }
docs: Constructs a new Element implementation that checks and converts values for a
  particular field type, as appropriate.
  
  An Element represents a single value: either the value of a singular field,
  or a value contained in one entry of a repeated field or map field. This
  class does not implement these higher-level concepts; it only encapsulates
  the low-level typechecking and conversion.
  
  @exports ProtoBuf.Reflect.Element
  @param {{name: string, wireType: number}} type Resolved data type
  @param {ProtoBuf.Reflect.T|null} resolvedType Resolved type, if relevant
  (e.g. submessage field).
  @param {boolean} isMapKey Is this element a Map key? The value will be
  converted to string form if so.
  @param {string} syntax Syntax level of defining message type, e.g.,
  proto2 or proto3.
  @constructor