anchor.diff:  * the full dotted path to the field, with <<path-match-unmatch,`path_match` and `path_unmatch`>>.
   
   The original field name `{name}` and the detected datatype
  -`{dynamic_type`} <<template-variables,template variables>> can be used in
  +`{dynamic_type}` <<template-variables,template variables>> can be used in
   the mapping specification as placeholders.
   
   IMPORTANT: Dynamic field mappings are only added when a field contains a
   concrete value -- not `null` or an empty array. This means that if the
  -`null_value` option  is used in a `dynamic_template`, it will only be applied
  -after the first document  with a concrete value for the field has been
  +`null_value` option is used in a `dynamic_template`, it will only be applied
  +after the first document with a concrete value for the field has been
   indexed.
   
   Dynamic templates are specified as an array of named objects:
  
positive.code: [[match-mapping-type]]
  ==== `match_mapping_type`
  
  The `match_mapping_type` is the datatype detected by the json parser. Since
  JSON doesn't allow to distinguish a `long` from an `integer` or a `double` from
  a `float`, it will always choose the wider datatype, i.e. `long` for integers
  and `double` for floating-point numbers.
  
  The following datatypes may be automatically detected:
  
   - `boolean` when `true` or `false` are encountered.
   - `date` when <<date-detection,date detection>> is enabled and a string is
     found that matches any of the configured date formats.
   - `double` for numbers with a decimal part.
   - `long` for numbers without a decimal part.
   - `object` for objects, also called hashes.
  
negative.code: <2> The match conditions can include any of : `match_mapping_type`, `match`, `match_pattern`, `unmatch`, `path_match`, `path_unmatch`.
  <3> The mapping that the matched field should use.
  
  If a provided mapping contains an invalid mapping snippet, a validation error
  is returned. Validation occurs when applying the dynamic template at index time, 
  and, in most cases, when the dynamic template is updated. Providing an invalid mapping 
  snippet may cause the update or validation of a dynamic template to fail under certain conditions:
  
  * If no `match_mapping_type` has been specified but the template is valid for at least one predefined mapping type, 
    the mapping snippet is considered valid. However, a validation error is returned at index time if a field matching 
    the template is indexed as a different type. For example, configuring a dynamic template with no `match_mapping_type` 
    is considered valid as string type, but if a field matching the dynamic template is indexed as a long, a validation 
    error is returned at index time.
  
  * If the `{{name}}` placeholder is used in the mapping snippet, validation is skipped when updating the dynamic 
    template. This is because the field name is unknown at that time. Instead, validation occurs when the template is applied
    at index time.
  
  Templates are processed in order -- the first matching template wins. When
  putting new dynamic templates through the <<indices-put-mapping, put mapping>> API,
  