private void addJsonTypeInfo(JDefinedClass klass,ObjectTypeDeclaration type) {
    if (!context.getConfig().isJacksonTypeInfo()) {
        return;
    }
    if (type.discriminator() == null) {
        return;
    }
    List<String> derivedTypes = context.getApiModel().findDerivedTypes(type.name());
    if (derivedTypes.isEmpty()) {
        return;
    }
    JAnnotationUse typeInfo = klass.annotate(JsonTypeInfo.class);
    typeInfo.param("use",Id.NAME);
    typeInfo.param("include",As.EXISTING_PROPERTY);
    typeInfo.param("property",type.discriminator());

    JAnnotationUse subTypes = klass.annotate(JsonSubTypes.class);
    JAnnotationArrayMember typeArray = subTypes.paramArray(VALUE);

    for (String derivedType : derivedTypes) {
        JDefinedClass subtype = pkg._getClass(derivedType);
        typeArray.annotate(Type.class).param(VALUE,subtype);
    }
}

/**
 * Build the code to initialize a {@link TypeSerializationInfo} or {@link TypeDeserializationInfo}.
 *
 * @param typeInfo the type information obtained through the {@link JsonTypeInfo} annotation
 * @return the code built
 */
protected final CodeBlock generateTypeInfo( BeanTypeInfo typeInfo ) {

    Class type;
    ImmutableMap<JClasstype,String> mapTypetoMetadata;
    if ( isSerializer() ) {
        type = TypeSerializationInfo.class;
        mapTypetoMetadata = typeInfo.getMapTypetoSerializationMetadata();
    } else {
        type = TypeDeserializationInfo.class;
        mapTypetoMetadata = typeInfo.getMapTypetoDeserializationMetadata();
    }

    CodeBlock.Builder builder = CodeBlock.builder()
            .add( "new $T($T.$L,$S)",type,As.class,typeInfo.getInclude(),typeInfo.getPropertyName() )
            .indent()
            .indent();

    for ( Entry<JClasstype,String> entry : mapTypetoMetadata.entrySet() ) {
        builder.add( "\n.addTypeInfo($T.class,rawName( entry.getKey() ),entry.getValue() );
    }

    return builder.unindent().unindent().build();
}

/**
 * Process the properties of the bean to find additionnal informations like @JsonValue.
 *
 * @param configuration the configuration
 * @param logger the logger
 * @param typeOracle the oracle
 * @param beanInfo the prevIoUs bean information
 * @param properties the properties of the bean
 * @return the new informations about the bean and its properties
 */
public static BeanInfo processproperties( RebindConfiguration configuration,TreeLogger logger,JacksonTypeOracle typeOracle,BeanInfo beanInfo,PropertiesContainer properties ) {
    if ( !properties.getValuePropertyInfo().isPresent() && !properties.getAnyGetterPropertyInfo().isPresent() && !properties
            .getAnySetterPropertyInfo().isPresent() ) {
        return beanInfo;
    }

    BeanInfoBuilder builder = new BeanInfoBuilder( beanInfo );
    builder.setValuePropertyInfo( properties.getValuePropertyInfo() );

    if ( properties.getValuePropertyInfo().isPresent() && beanInfo.getTypeInfo().isPresent() && As.PROPERTY.equals( beanInfo
            .getTypeInfo().get().getInclude() ) ) {
        // if the bean has type info on property with @JsonValue,we change it to WRAPPER_ARRAY because the value may not be an object
        BeanTypeInfo typeInfo = beanInfo.getTypeInfo().get();
        builder.setTypeInfo( Optional.of( new BeanTypeInfo( typeInfo.getUse(),As.WRAPPER_ARRAY,typeInfo
                .getPropertyName(),typeInfo.getMapTypetoSerializationMetadata(),typeInfo.getMapTypetoDeserializationMetadata() ) ) );
    }

    builder.setAnyGetterPropertyInfo( properties.getAnyGetterPropertyInfo() );
    builder.setAnySetterPropertyInfo( properties.getAnySetterPropertyInfo() );

    return builder.build();
}

private Jackson2JsonRedisSerializer jsonRedisSerializer(JavaType javaType)
{
    Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(javaType);
    ObjectMapper mapper = new ObjectMapper();
    mapper.enableDefaultTyping();
    mapper.enableDefaultTyping(DefaultTyping.NON_FINAL,As.PROPERTY);

    mapper.findAndRegisterModules();
    mapper.registerModule(new Jackson2HalModule());
    mapper.setHandlerInstantiator(new Jackson2HalModule.HalHandlerInstantiator(new DefaultRelProvider(),null,null));        
    jackson2JsonRedisSerializer.setobjectMapper(mapper);        
    return jackson2JsonRedisSerializer;
}

public StdTypeResolverBuilder inclusion(JsonTypeInfo.As paramAs)
{
  if (paramAs == null)
    throw new IllegalArgumentException("includeAs can not be null");
  this._includeAs = paramAs;
  return this;
}

protected TypeResolverBuilder<?> _findTypeResolver(MapperConfig<?> paramMapperConfig,Annotated paramAnnotated,JavaType paramJavaType)
{
  JsonTypeInfo localJsonTypeInfo = (JsonTypeInfo)paramAnnotated.getAnnotation(JsonTypeInfo.class);
  JsonTypeResolver localJsonTypeResolver = (JsonTypeResolver)paramAnnotated.getAnnotation(JsonTypeResolver.class);
  Object localObject;
  if (localJsonTypeResolver != null)
  {
    if (localJsonTypeInfo == null)
      return null;
    localObject = paramMapperConfig.typeResolverBuilderInstance(paramAnnotated,localJsonTypeResolver.value());
  }
  else
  {
    if (localJsonTypeInfo == null)
      return null;
    if (localJsonTypeInfo.use() == JsonTypeInfo.Id.NONE)
      return _constructNoTypeResolverBuilder();
    localObject = _constructStdTypeResolverBuilder();
  }
  JsonTypeIdResolver localJsonTypeIdResolver = (JsonTypeIdResolver)paramAnnotated.getAnnotation(JsonTypeIdResolver.class);
  TypeIdResolver localTypeIdResolver1;
  if (localJsonTypeIdResolver == null)
    localTypeIdResolver1 = null;
  else
    localTypeIdResolver1 = paramMapperConfig.typeIdResolverInstance(paramAnnotated,localJsonTypeIdResolver.value());
  TypeIdResolver localTypeIdResolver2 = localTypeIdResolver1;
  if (localTypeIdResolver1 != null)
    localTypeIdResolver2.init(paramJavaType);
  TypeResolverBuilder localTypeResolverBuilder1 = ((TypeResolverBuilder)localObject).init(localJsonTypeInfo.use(),localTypeIdResolver2);
  JsonTypeInfo.As localAs1 = localJsonTypeInfo.include();
  JsonTypeInfo.As localAs2 = localAs1;
  if ((localAs1 == JsonTypeInfo.As.EXTERNAL_PROPERTY) && ((paramAnnotated instanceof AnnotatedClass)))
    localAs2 = JsonTypeInfo.As.PROPERTY;
  TypeResolverBuilder localTypeResolverBuilder2 = localTypeResolverBuilder1.inclusion(localAs2).typeProperty(localJsonTypeInfo.property());
  Class localClass = localJsonTypeInfo.defaultImpl();
  if (localClass != JsonTypeInfo.None.class)
    localTypeResolverBuilder2 = localTypeResolverBuilder2.defaultImpl(localClass);
  return localTypeResolverBuilder2.typeIdVisibility(localJsonTypeInfo.visible());
}

public JsonObjectMapper() {
    registerModule(module);

    configure(MapperFeature.REQUIRE_SETTERS_FOR_GETTERS,true);
    configure(SerializationFeature.FAIL_ON_EMPTY_BEANS,false);
    enableDefaultTyping(DefaultTyping.NON_FINAL,As.WRAPPER_OBJECT);

    typer = new ClassAliasTypeResolverBuilder(DefaultTyping.NON_FINAL);
    setDefaultTyping(typer.inclusion(As.WRAPPER_OBJECT));
}

/**
 * <p>processtype</p>
 *
 * @param logger a {@link com.google.gwt.core.ext.TreeLogger} object.
 * @param typeOracle a {@link com.github.nmorel.gwtjackson.rebind.JacksonTypeOracle} object.
 * @param configuration a {@link com.github.nmorel.gwtjackson.rebind.RebindConfiguration} object.
 * @param typeOracle a {@link com.github.nmorel.gwtjackson.rebind.JacksonTypeOracle} object.
 * @param type a {@link com.google.gwt.core.ext.typeinfo.JClasstype} object.
 * @param jsonTypeInfo a {@link com.google.gwt.thirdparty.guava.common.base.Optional} object.
 * @param propertySubTypes a {@link com.google.gwt.thirdparty.guava.common.base.Optional} object.
 * @return a {@link com.google.gwt.thirdparty.guava.common.base.Optional} object.
 * @throws com.google.gwt.core.ext.UnabletoCompleteException if any.
 */
public static Optional<BeanTypeInfo> processtype( TreeLogger logger,RebindConfiguration configuration,JClasstype type,Optional<JsonTypeInfo> jsonTypeInfo,Optional<JsonSubTypes>
        propertySubTypes ) throws UnabletoCompleteException {

    if ( !jsonTypeInfo.isPresent() ) {
        jsonTypeInfo = findFirstEncounteredAnnotationsOnAllHierarchy( configuration,JsonTypeInfo.class );
        if ( !jsonTypeInfo.isPresent() ) {
            return Optional.absent();
        }
    }

    Id use = jsonTypeInfo.get().use();
    As include = jsonTypeInfo.get().include();
    String propertyName = jsonTypeInfo.get().property().isEmpty() ? jsonTypeInfo.get().use().getDefaultPropertyName() : jsonTypeInfo
            .get().property();

    Optional<JsonSubTypes> typeSubTypes = findFirstEncounteredAnnotationsOnAllHierarchy( configuration,JsonSubTypes.class );

    // Todo we Could do better,we actually extract Metadata twice for a lot of classes
    ImmutableMap<JClasstype,String> classtoSerializationMetadata = extractMetadata( logger,configuration,jsonTypeInfo,propertySubTypes,typeSubTypes,CreatorUtils
                    .filterSubtypesForSerialization( logger,type ) );
    ImmutableMap<JClasstype,String> classtoDeserializationMetadata = extractMetadata( logger,CreatorUtils
                    .filterSubtypesForDeserialization( logger,type ) );

    return Optional.of(
            new BeanTypeInfo( use,include,propertyName,classtoSerializationMetadata,classtoDeserializationMetadata ) );
}

BeanTypeInfo( Id use,As include,String propertyName,ImmutableMap<JClasstype,String> mapTypetoSerializationMetadata,String> mapTypetoDeserializationMetadata ) {
    this.use = use;
    this.include = include;
    this.propertyName = propertyName;
    this.mapTypetoSerializationMetadata = mapTypetoSerializationMetadata;
    this.mapTypetoDeserializationMetadata = mapTypetoDeserializationMetadata;
}

@JsonTypeInfo(use = Id.NAME,include = As.EXISTING_PROPERTY)
public AntiochQuery getQuery() {
  return query;
}

public JsonTypeInfo.As getTypeInclusion()
{
  return JsonTypeInfo.As.PROPERTY;
}

public JsonTypeInfo.As getTypeInclusion()
{
  return JsonTypeInfo.As.WRAPPER_ARRAY;
}

public JsonTypeInfo.As getTypeInclusion()
{
  return JsonTypeInfo.As.WRAPPER_OBJECT;
}

public JsonTypeInfo.As getTypeInclusion()
{
  return JsonTypeInfo.As.WRAPPER_OBJECT;
}

public JsonTypeInfo.As getTypeInclusion()
{
  return JsonTypeInfo.As.PROPERTY;
}

public JsonTypeInfo.As getTypeInclusion()
{
  return JsonTypeInfo.As.WRAPPER_ARRAY;
}

public JsonTypeInfo.As getTypeInclusion()
{
  return JsonTypeInfo.As.EXTERNAL_PROPERTY;
}

public JsonTypeInfo.As getTypeInclusion()
{
  return JsonTypeInfo.As.EXTERNAL_PROPERTY;
}

/** @return the identifier */
@JsonTypeInfo(use=JsonTypeInfo.Id.CLASS,include=As.PROPERTY,property="class")
ID getID();

@Override
public As getTypeInclusion() {
    return As.PROPERTY;
}

@Override
public As getTypeInclusion() {
    return As.WRAPPER_ARRAY;
}

@Override
public As getTypeInclusion() {
    return As.WRAPPER_OBJECT;
}

@Override
public As getTypeInclusion() { return As.WRAPPER_OBJECT; }

@Override
public As getTypeInclusion() { return As.PROPERTY; }

@Override
public As getTypeInclusion() { return As.WRAPPER_ARRAY; }

@Override
public As getTypeInclusion() {
    return As.EXTERNAL_PROPERTY;
}

@Override
public As getTypeInclusion() { return As.EXTERNAL_PROPERTY; }

/**
 * <p>Constructor for TypeSerializationInfo.</p>
 *
 * @param include      a {@link com.fasterxml.jackson.annotation.JsonTypeInfo.As} object.
 * @param propertyName a {@link String} object.
 */
public TypeSerializationInfo(As include,String propertyName) {
    this.include = include;
    this.propertyName = propertyName;
    this.typeClasstoInfo = new HashMap<Class<? extends T>,String>();
}

/**
 * <p>Getter for the field <code>include</code>.</p>
 *
 * @return a {@link com.fasterxml.jackson.annotation.JsonTypeInfo.As} object.
 */
public As getInclude() {
    return include;
}

/**
 * <p>Constructor for TypeDeserializationInfo.</p>
 *
 * @param include      a {@link As} object.
 * @param propertyName a {@link String} object.
 */
public TypeDeserializationInfo(As include,String propertyName) {
    this.include = include;
    this.propertyName = propertyName;
    this.typeInfoToClass = new HashMap<String,Class<? extends T>>();
}

/**
 * <p>Getter for the field <code>include</code>.</p>
 *
 * @return a {@link As} object.
 */
public As getInclude() {
    return include;
}

/**
 * <p>Constructor for TypeSerializationInfo.</p>
 *
 * @param include a {@link com.fasterxml.jackson.annotation.JsonTypeInfo.As} object.
 * @param propertyName a {@link java.lang.String} object.
 */
public TypeSerializationInfo( As include,String propertyName ) {
    this.include = include;
    this.propertyName = propertyName;
    this.typeClasstoInfo = new HashMap<Class<? extends T>,String>();
}

/**
 * <p>Getter for the field <code>include</code>.</p>
 *
 * @return a {@link com.fasterxml.jackson.annotation.JsonTypeInfo.As} object.
 */
public As getInclude() {
    return include;
}

/**
 * <p>Constructor for TypeDeserializationInfo.</p>
 *
 * @param include a {@link com.fasterxml.jackson.annotation.JsonTypeInfo.As} object.
 * @param propertyName a {@link java.lang.String} object.
 */
public TypeDeserializationInfo( As include,String propertyName ) {
    this.include = include;
    this.propertyName = propertyName;
    this.typeInfoToClass = new HashMap<String,Class<? extends T>>();
}

/**
 * <p>Getter for the field <code>include</code>.</p>
 *
 * @return a {@link com.fasterxml.jackson.annotation.JsonTypeInfo.As} object.
 */
public As getInclude() {
    return include;
}

/**
 * <p>Getter for the field <code>include</code>.</p>
 *
 * @return a {@link com.fasterxml.jackson.annotation.JsonTypeInfo.As} object.
 */
public As getInclude() {
    return include;
}

/**
 * Accessor for type information inclusion method
 * that deserializer uses; indicates how type information
 * is (expected to be) embedded in JSON input.
 */
public abstract As getTypeInclusion();

/**
 * Method for specifying mechanism to use for including type Metadata
 * in JSON.
 * If not explicitly called,setting defaults to
 * {@link As#PROPERTY}.
 * 
 * @param includeAs Mechanism used for including type Metadata in JSON
 * 
 * @return Resulting builder instance (usually this builder,*   but not necessarily)
 */
public T inclusion(As includeAs);

public abstract JsonTypeInfo.As getTypeInclusion();

public abstract JsonTypeInfo.As getTypeInclusion();