anchor.diff:  }
   ----
   
  -And then you should have the Camel Maven Package Plugin in as build plugin when compiling the project.
  -Also add the build helper plugin which ensures the generated source code in `src/generated` will be included in the source path.
  -
  -When using Maven you add:
  -
  -[source,xml]
  -----
  -      <plugin>
  -        <groupId>org.apache.camel</groupId>
  -        <artifactId>camel-package-maven-plugin</artifactId>
  -        <version>${camel-version}</version>
  -        <executions>
  -          <execution>
  -            <id>generate</id>
  -            <goals>
  -              <goal>generate-component</goal>
  -            </goals>
  -            <phase>process-classes</phase>
  -          </execution>
  -        </executions>
  -      </plugin>
  -      <plugin>
  -        <groupId>org.codehaus.mojo</groupId>
  -        <artifactId>build-helper-maven-plugin</artifactId>
  -        <executions>
  -          <execution>
  -            <phase>initialize</phase>
  -            <goals>
  -              <goal>add-source</goal>
  -              <goal>add-resource</goal>
  -            </goals>
  -            <configuration>
  -              <sources>
  -                <source>src/generated/java</source>
  -              </sources>
  -              <resources>
  -                <resource>
  -                  <directory>src/generated/resources</directory>
  -                </resource>
  -              </resources>
  -            </configuration>
  -          </execution>
  -        </executions>
  -      </plugin>
  -----
  -
  -[[TypeConverter-Returningnullvalues]]
  -=== Returning null values
  -
  -By default when using a method in a POJO annotation with @Converter
  -returning null is not a valid response. If null is returned, then Camel
  -will regard that type converter as a _miss_, and prevent from using it
  -in the future. If null should be allowed as a valid response, then from
  -*Camel 2.11.2/2.12* onwards you can specify this in the annotation as
  -shown:
  -
  -[source,java]
  -----
  -@Converter(allowNull = true)
  -public static InputStream toInputStream(File file) throws IOException {
  -    if (file.exist()) {
  +This is from camel-core where the `IOConverter` class has a number of converters (only 1 shown).
  +The method `toInputStream` is annotated with `@Converter` which then becomes a type converter
  +that can convert from `File` to `InputStream`.
  +
  +All these _converter_ classes are discovered and loaded by Camel.
  +
  +== Discovering Type Converters
  +
  +Camel automatically discovers and loads the type converters from all JARs on the classpath at startup.
  +
  +Camel searches the classpath for a file called
  +`META-INF/services/org/apache/camel/TypeConverterLoader` which lists
  +all type converter loader classes. These are automatically generated by the Camel Component Package Plugin.
  +These _loader_ classes will load the type converters into the Camel type converter registry
  +and invoke them in a _fast way_ using standard Java method calls.
  +
  +=== Discovering Type Converters (fast way)
  +
  +To enable the fast type converter way, you should enable `generateLoader = true`
  +on the class level annotation as shown:
  +
  +[source,java]
  +----
  +@Converter(generateLoader = true)
  +public class IOConverter {
  +    @Converter
  +    public static InputStream toInputStream(File file) throws FileNotFoundException {
           return new BufferedInputStream(new FileInputStream(file));
  -    } else {
  -        return null;
  -    }
  -}
  -----
  +    }
  +}
  +----
  +
  +And then you should have the xref:camel-component-maven-plugin.adoc[Camel Component Package Plugin] in as build plugin when compiling the project.
   
   === Discovering Type Converters in the fastest way
  -
  -*Available in Camel 3.7*
   
   In Camel 3.7 we optimized the type converter system for optimal performance when using the built-in converters.
   This was done by bulking together all the converters in the same Maven module into a single class. The class has a single
  
positive.code: }
  ----
  
  [[TypeConverter-WritingyourownTypeConverters]]
  == Writing your own Type Converters
  
  You are welcome to write your own converters. Remember to use the
  `@Converter` annotations on the classes and methods you wish to use.
  And on the top-level class add `Converter(loader = true)` to support the _fast way_
  of using type converters.
  
  * static methods are encouraged to reduce caching, but instance methods
  
negative.code: 
  [source,xml]
  ----
  <camelContext typeConverterStatisticsEnabled="true">
      ...
  </camelContext>
  ----
  
  == TypeConverter using @Converter annotation
  
  All the type converters that comes out of the box are coded as Java methods on _converter_ classes.
  
  This means a class has been annotated with `@Converter` and the methods in the class
  becomes a type converter _pair_ when the methods is also annotated with `@Converter` such as:
  
  [source,java]
  ----
  