anchor.diff:  
   ## Virtual Attributes
   
  -There are entity properties that are not directly modificable by NGSIv2 clients, but that can be rendered
  -by NGSIv2 servers to provide extra information. From a representation point of view, they are like
  -regular attributes, with name, value and type.
  -
  -Virtual attributes are not rendered by default. In oder to render an specific attribute, add its name
  +There are entity properties that are not directly modifiable by NGSIv2 clients, but that can be
  +rendered by NGSIv2 servers to provide extra information. From a representation point of view, they
  +are just like regular attributes, with name, value and type.
  +
  +Virtual attributes are not rendered by default. In order to render a specific attribute, add its name
   to the `options` URL parameter.
   
  -The list of virtual attributes is the following:
  -
  -* `dateCreated` (type: `date`): entity creation date as ISO 8601 string.
  -* `dateModified` (type: `date`): entity modification date as ISO 8601 string.
  -
  -As regular attributes, they can be  used in `attrs`, `q` filters and `orderBy`. However, they cannot be used
  -in resource URLs.
  -
  +The list of virtual attributes is as follows:
  +
  +* `dateCreated` (type: `date`): entity creation date as an ISO 8601 string.
  +* `dateModified` (type: `date`): entity modification date as an ISO 8601 string.
  +
  +Like regular attributes, they can be  used in `attrs`, `q` filters and `orderBy`.
  +However, they cannot be used in resource URLs.
   
   ## Field syntax restrictions
   
  -Fields used as identifiers in the NGSIv2 API follow special rules regarding allowed syntax. These rules applies to:
  +Fields used as identifiers in the NGSIv2 API follow special rules regarding allowed syntax.
  +These rules apply to:
   
   * Entity id
   * Entity type
  
positive.code: }
  ```
  
  * *values mode*. This mode represents the entity only by a collection of attribute values conveyed by an Array. Id and type information are left out.
    See example below. The order of the attributes in the Array is specified by the `attrs` URI param (e.g. `attrs=branch,colour,engine`) or arbitrary
    order in the case `attrs` is not used.
  
  ```
  [ 'Ford', 'black', 78.3 ]
  ```
  
  * *unique mode*. This mode is just like *values mode*, with the only difference that values are not repeated.
  
  ## Partial Representations
  
  Some operations imply that only a partial representation of an entity will be provided, which are summarized below:
  
  * `id` and `type` are not allowed in update operations, as they are inmutable properties.
  
  * In the requests in which entity `type` is allowed, it may be omitted. When omitted in entity creation operations,
    the default string value `none` is used for the type.
  
  * In some cases, not all the attributes of the entity are shown, e.g. a query which selects a subset of entity attributes.
  
  * Attribute/metadata `value` may be omitted in requests, meaning that the attribute/metadata has `null` value. It is always present in responses.
  
  * Attribute/metadata `type` may be ommitted in requests. When omitted in attribute/metadata creation or update operations, the default
    string value `none` is used for the type.
  
  * Attribute `metadata` may be ommitted in requests, meaning that there are not metadata elements associated to the attribute. In responses, this property is set to
    `{}` if the attribute doesn't have metadata.
  
  
  ## Special Attribute Types
  
  Generally speaking, user-defined attribute types are informative, they are processed by the NGSIv2 server in
  an opaque way. Nonetheless, the types described below are used to convey an special meaning
  
  * `date`:  identifies dates, in ISO8601 format. These attributes can be used with the
    greater than, less than, greater or equal, lesser or equal and range query operators. For instance
    (only the referred entity attribute is shown) :
  
  ```
  {
  
negative.code: 
  An entity is represented by a JSON object with the following syntax:
  
  * The entity id is specified by the object's `id` property, whose value is a string containing the
    entity id.
  
  * The entity type is specified by the object's `type` property, whose value is a string containing
    the entity's type name.
  
  * Entity attributes are specified by additional properties, whose names are the `name` of the 
    attribute and whose representation is described in the "JSON Attribute Representation" section
    below. Obviously, `id` and `type` are not allowed to be used as attribute names.
  
  An example of this syntax in shown below:
  
  