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: * `byte[]` and `ByteBuffer`
  * `InputStream` and `OutputStream`
  * `Reader` and `Writer`
  * `Document` and `Source`
  
  To convert the body of a message to another type:
  
  [source,java]
  ----
  Message message = exchange.getIn();
  Document document = message.getBody(Document.class); // <1>
  ----
  <1> where https://www.javadoc.io/doc/org.apache.camel/camel-api/current/org/apache/camel/Message.html#getBody-java.lang.Class-[`Message#getBody(Class)`] performs the conversion.
  
  [[TypeConverter-HowTypeConversionworks]]
  == How Type Conversion works
  
  The type conversion strategy is defined by the
  https://www.javadoc.io/doc/org.apache.camel/camel-api/current/org/apache/camel/TypeConverter.html[TypeConverter]
  interface that can be customized on a
  https://www.javadoc.io/doc/org.apache.camel/camel-api/current/org/apache/camel/CamelContext.html[CamelContext].
  
  Camel provides a default type converter registry.
  From Camel 3 onwards, the type converter registry implementation generates source code using the Camel Maven
  Package Plugin, allowing Camel, at runtime, to load and invoke these type converters via
  quick Java method invocations. In Camel 2, type converters are registered using annotation based discovery, invoking the type converters via the https://docs.oracle.com/javase/tutorial/reflect/[Java Reflection API].
  
  
  [[TypeConverter-TypeConverterRegistry]]
  == TypeConverterRegistry
  
  Add a `TypeConverter` to the
  https://www.javadoc.io/doc/org.apache.camel/camel-api/current/org/apache/camel/spi/TypeConverterRegistry.html[`TypeConverterRegistry`]
  at runtime using the xref:camelcontext.adoc[CamelContext]:
  
  [source,java]
  ----
  CamelContext context = ...;
  context.getTypeConverterRegistry();
  ----
  
  NOTE: This is useful on platforms where the automatic type converters discovery fails due to classloading issues.
  
  [[TypeConverter-TypeConverterRegistryutilizationstatistics]]
  === TypeConverterRegistry utilization statistics
  
  Camel can gather utilization statistics of the runtime usage of type
  converters. These statistics are available in JMX as well as
  from https://www.javadoc.io/doc/org.apache.camel/camel-api/latest/org/apache/camel/spi/TypeConverterRegistry.html#getStatistics--[`TypeConverterRegistry#getStatistics()`].
  
  These statistics are turned off by
  default as there is some performance overhead under very high concurrent
  load.
  
  Enabling statistics in Java:
  
  
negative.code: injection to customize the converter
  * converter methods should be thread safe and reentrant
  
  === Exchange parameter
  
  The type converter accepts the `Exchange` as an optional 2nd parameter.
  This is usable if the type converter for instance needs information from
  