anchor.diff:  }
   ```
   
  -Notifications must include a `Ngsiv2-AttrsFormat` header with the value of `attrsFormat` of the associated subscription,
  -so notification receiver can know the format used without needing processing notification payload.
  +Notifications must include a `Ngsiv2-AttrsFormat` HTTP header with the value of the format of the
  +associated subscription, so that the notification receiver is aware of the format without
  +needing to process the notification payload.
   
   ## Custom Notifications
   
   NGSIv2 clients can customize HTTP notification messages using a simple template mechanism. The
  -`notification.httpCustom` property of a subscription allows to specify the following fields subject
  +`notification.httpCustom` property of a subscription allows to specify the following fields
   to be templatized:
   
   * `url`
  -* `headers` (both header names and values)
  -* `qs` (both in parameter names and values)
  +* `headers` (both header name and value can be templatized)
  +* `qs` (both parameter name and value can be templatized)
   * `payload`
   
  -In addition the HTTP method to be used for delivering the notification can be customized as well using the `method` field,
  -but it cannot be a template.
  +The fifth field `method`, lets the NGSIv2 clients select the HTTP method to be used for delivering
  +the notification, but note that only valid HTTP verbs can be used: GET, PUT, POST, DELETE, PATCH,
  +HEAD, OPTIONS, TRACE, and CONNECT.
  +
   
   Macro substitution for templates is based on the syntax `${..}`. In particular:
   
  
positive.code: 
  An entity is represented by a JSON object with the following syntax:
  
  * The entity id is specified by the object's `id` property, which value is a string containing the entity id.
  
  * The entity type is specified by the object's `type` property, which value is a string containing the entity's type name.
  
  * Entity attributes are specified by additional properties, which name is the `name` of the attribute and which representation
    is described in the "JSON Attribute Representation" section below. Obviously, `id` and `type` are not allowed as attribute names.
  
  An example of this syntax in shown below:
  
  
negative.code: }
  ```
  
  * *values mode*. This mode represents the entity as an array of attribute values.
    Information about id and type is 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`). If `attrs` is not used, the order is arbitrary.
  
  ```
  [ 'Ford', 'black', 78.3 ]
  ```
  
  * *unique mode*. This mode is just like *values mode*, except that values are not repeated.
  
  ## Partial Representations
  
  Some operations use partial representation of entities:
  
  * `id` and `type` are not allowed in update operations, as they are immutable properties.
  
  * In requests where 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 selecting a subset
    of the entity attributes.
  
  * Attribute/metadata `value` may be omitted in requests, meaning that the attribute/metadata has
    `null` value. In responses, the value is always present.
  
  * Attribute/metadata `type` may be omitted in requests. When omitted in attribute/metadata creation
    or in update operations, the default string value `none` is used for the type.
  
  * Attribute `metadata` may be omitted in requests, meaning that there are no metadata elements
    associated to the attribute. In responses, this property is set to
    `{}` if the attribute doesn't have any 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 a special meaning:
  
  * `date`:  identifies dates, in ISO8601 format. These attributes can be used with the query operators
    greater-than, less-than, greater-or-equal, less-or-equal and range. For instance
    (only the referred entity attribute is shown):
  
  ```
  {
  