diff --git a/rosetta-ide/src/main/java/com/regnosys/rosetta/ide/server/RosettaRequestManager.java b/rosetta-ide/src/main/java/com/regnosys/rosetta/ide/server/RosettaRequestManager.java
index 7a4e37d92..b1568c908 100644
--- a/rosetta-ide/src/main/java/com/regnosys/rosetta/ide/server/RosettaRequestManager.java
+++ b/rosetta-ide/src/main/java/com/regnosys/rosetta/ide/server/RosettaRequestManager.java
@@ -33,6 +33,7 @@ public class RosettaRequestManager extends RequestManager {
 	                        .build());
 
 	/*
+	 * TODO: contribute to Xtext
 	 * The code that uses this list fixes a memory leak in the RequestManager and should be contributed
 	 * back to the Xtext project then removed from here
 	 */
diff --git a/rosetta-lang/src/main/java/com/regnosys/rosetta/generator/java/expression/ExpressionGenerator.xtend b/rosetta-lang/src/main/java/com/regnosys/rosetta/generator/java/expression/ExpressionGenerator.xtend
index 3849c664a..07143da95 100644
--- a/rosetta-lang/src/main/java/com/regnosys/rosetta/generator/java/expression/ExpressionGenerator.xtend
+++ b/rosetta-lang/src/main/java/com/regnosys/rosetta/generator/java/expression/ExpressionGenerator.xtend
@@ -108,9 +108,7 @@ import com.regnosys.rosetta.types.builtin.RRecordType
 import java.util.stream.Collectors
 import com.regnosys.rosetta.rosetta.RosettaRule
 import com.rosetta.util.types.JavaType
-import com.rosetta.model.lib.mapper.Mapper
 import com.rosetta.util.types.JavaPrimitiveType
-import com.rosetta.model.lib.mapper.MapperListOfLists
 import com.regnosys.rosetta.types.RShortcut
 import com.regnosys.rosetta.types.RFunction
 import com.regnosys.rosetta.generator.java.types.JavaTypeUtil
@@ -119,6 +117,7 @@ import com.regnosys.rosetta.generator.java.statement.builder.JavaStatementBuilde
 import com.regnosys.rosetta.generator.java.statement.builder.JavaExpression
 import com.regnosys.rosetta.generator.java.statement.builder.JavaVariable
 import com.regnosys.rosetta.generator.java.statement.builder.JavaIfThenElseBuilder
+import com.rosetta.util.types.JavaGenericTypeDeclaration
 
 class ExpressionGenerator extends RosettaExpressionSwitch<JavaStatementBuilder, ExpressionGenerator.Context> {
 	
@@ -233,18 +232,18 @@ class ExpressionGenerator extends RosettaExpressionSwitch<JavaStatementBuilder,
 	private def JavaStatementBuilder implicitVariable(EObject context, JavaScope scope) {
 		val itemType = typeProvider.typeOfImplicitVariable(context).toJavaReferenceType
 		val definingContainer = context.findContainerDefiningImplicitVariable.get
-		val actualType = if (definingContainer instanceof Data || definingContainer instanceof RosettaRule) {
+		val JavaType actualType = if (definingContainer instanceof Data || definingContainer instanceof RosettaRule) {
 			// For conditions and rules
 			itemType
 		} else {
 			// For inline functions
 			val f = definingContainer as RosettaFunctionalOperation
 			if (f instanceof ThenOperation && f.argument.isOutputListOfLists) {
-				MapperListOfLists.wrap(itemType)
+				MAPPER_LIST_OF_LISTS.wrap(itemType) as JavaType
 			} else if (context.implicitVariableMulti) {
-				MapperC.wrap(itemType)
+				MAPPER_C.wrap(itemType) as JavaType
 			} else {
-				MapperS.wrap(itemType)
+				MAPPER_S.wrap(itemType) as JavaType
 			}
 		}
 		new JavaVariable(scope.getIdentifierOrThrow(context.implicitVarInContext), actualType)
@@ -281,11 +280,11 @@ class ExpressionGenerator extends RosettaExpressionSwitch<JavaStatementBuilder,
 			default:
 				throw new UnsupportedOperationException("Unsupported feature type of " + feature?.class?.name)
 		}
-		val mapperReceiverCode = typeCoercionService.addCoercions(receiverCode, Mapper.wrapExtends(resultItemType), scope)
+		val mapperReceiverCode = typeCoercionService.addCoercions(receiverCode, MAPPER.wrapExtends(resultItemType), scope)
 		val resultWrapper = if (mapperReceiverCode.expressionType.isMapperS && !cardinalityProvider.isFeatureMulti(feature)) {
-			MapperS
+			MAPPER_S as JavaGenericTypeDeclaration<?>
 		} else {
-			MapperC
+			MAPPER_C as JavaGenericTypeDeclaration<?>
 		}
 		val resultType = resultWrapper.wrap(resultItemType)
 		return mapperReceiverCode
@@ -322,29 +321,29 @@ class ExpressionGenerator extends RosettaExpressionSwitch<JavaStatementBuilder,
 					case "/": "divide"
 				}
 				if (leftType.extendsNumber && rightType.extendsNumber) {
-					val leftCode = javaCode(left, Mapper.wrapExtends(joined), context.scope)
-					val rightCode = javaCode(right, Mapper.wrapExtends(joined), context.scope)
+					val leftCode = javaCode(left, MAPPER.wrapExtends(joined), context.scope)
+					val rightCode = javaCode(right, MAPPER.wrapExtends(joined), context.scope)
 					leftCode
-						.then(rightCode, [l, r|JavaExpression.from('''«MapperMaths».<«resultType», «joined», «joined»>«method»(«l», «r»)''', MapperS.wrap(resultType))], context.scope)
+						.then(rightCode, [l, r|JavaExpression.from('''«MapperMaths».<«resultType», «joined», «joined»>«method»(«l», «r»)''', MAPPER_S.wrap(resultType))], context.scope)
 				} else {
-					val leftCode = javaCode(left, Mapper.wrapExtends(leftType), context.scope)
-					val rightCode = javaCode(right, Mapper.wrapExtends(rightType), context.scope)
+					val leftCode = javaCode(left, MAPPER.wrapExtends(leftType), context.scope)
+					val rightCode = javaCode(right, MAPPER.wrapExtends(rightType), context.scope)
 					leftCode
-						.then(rightCode, [l, r|JavaExpression.from('''«MapperMaths».<«resultType», «leftType», «rightType»>«method»(«l», «r»)''', MapperS.wrap(resultType))], context.scope)
+						.then(rightCode, [l, r|JavaExpression.from('''«MapperMaths».<«resultType», «leftType», «rightType»>«method»(«l», «r»)''', MAPPER_S.wrap(resultType))], context.scope)
 				}
 			}
 			case "contains",
 			case "disjoint": {
-				val leftCode = javaCode(left, Mapper.wrapExtends(joined), context.scope)
-				val rightCode = javaCode(right, Mapper.wrapExtends(joined), context.scope)
+				val leftCode = javaCode(left, MAPPER.wrapExtends(joined), context.scope)
+				val rightCode = javaCode(right, MAPPER.wrapExtends(joined), context.scope)
 				leftCode
 					.then(rightCode, [l, r|JavaExpression.from('''«runtimeMethod(expr.operator)»(«l», «r»)''', COMPARISON_RESULT)], context.scope)
 			}
 			case "join": {
-				val leftCode = javaCode(left, MapperC.wrapExtends(STRING), context.scope)
-				val rightCode = expr.right === null ? JavaExpression.from('''«MapperS».of("")''', resultType) : javaCode(right, MapperS.wrap(STRING), context.scope)
+				val leftCode = javaCode(left, MAPPER_C.wrapExtends(STRING), context.scope)
+				val rightCode = expr.right === null ? JavaExpression.from('''«MapperS».of("")''', resultType) : javaCode(right, MAPPER_S.wrap(STRING), context.scope)
 				leftCode
-					.then(rightCode, [l, r|JavaExpression.from('''«l».join(«r»)''', MapperS.wrap(STRING))], context.scope)
+					.then(rightCode, [l, r|JavaExpression.from('''«l».join(«r»)''', MAPPER_S.wrap(STRING))], context.scope)
 			}
 			case "=",
 			case "<>",
@@ -366,8 +365,8 @@ class ExpressionGenerator extends RosettaExpressionSwitch<JavaStatementBuilder,
 				} else {
 					CardinalityModifier.ALL
 				}
-				val leftCode = javaCode(left, Mapper.wrapExtends(joined), context.scope)
-				val rightCode = javaCode(right, Mapper.wrapExtends(joined), context.scope)
+				val leftCode = javaCode(left, MAPPER.wrapExtends(joined), context.scope)
+				val rightCode = javaCode(right, MAPPER.wrapExtends(joined), context.scope)
 				leftCode
 					.then(rightCode, [l, r|JavaExpression.from('''«runtimeMethod(method)»(«l», «r», «toCardinalityOperator(modifier, defaultModifier)»)''', COMPARISON_RESULT)], context.scope)
 			}
@@ -441,7 +440,7 @@ class ExpressionGenerator extends RosettaExpressionSwitch<JavaStatementBuilder,
 	private def buildConstraint(RosettaExpression arg, Iterable<Attribute> usedAttributes,
 		Necessity validationType, Context context) {
 		val argItemType = typeProvider.getRType(arg).toJavaReferenceType
-		arg.javaCode(Mapper.wrapExtends(argItemType), context.scope)
+		arg.javaCode(MAPPER.wrapExtends(argItemType), context.scope)
 			.collapseToSingleExpression(context.scope)
 			.mapExpression[JavaExpression.from('''«runtimeMethod('choice')»(«it», «Arrays».asList(«usedAttributes.join(", ")['"' + name + '"']»), «ChoiceRuleValidationMethod».«validationType.name()»)''', COMPARISON_RESULT)]
 	}
@@ -561,7 +560,7 @@ class ExpressionGenerator extends RosettaExpressionSwitch<JavaStatementBuilder,
 	}
 
 	override protected caseAbsentOperation(RosettaAbsentExpression expr, Context context) {
-		expr.argument.javaCode(Mapper.wrapExtends(expr.argument), context.scope)
+		expr.argument.javaCode(MAPPER.wrapExtends(expr.argument), context.scope)
 			.applyRuntimeMethod('notExists', COMPARISON_RESULT)
 	}
 
@@ -602,7 +601,7 @@ class ExpressionGenerator extends RosettaExpressionSwitch<JavaStatementBuilder,
 	}
 
 	override protected caseCountOperation(RosettaCountOperation expr, Context context) {
-		expr.argument.javaCode(Mapper.wrapExtends(expr.argument), context.scope)
+		expr.argument.javaCode(MAPPER.wrapExtends(expr.argument), context.scope)
 			.mapExpression[JavaExpression.from('''«it».resultCount()''', JavaPrimitiveType.INT)]
 	}
 
@@ -612,10 +611,10 @@ class ExpressionGenerator extends RosettaExpressionSwitch<JavaStatementBuilder,
 
 	override protected caseDistinctOperation(DistinctOperation expr, Context context) {
 		val argItemType = typeProvider.getRType(expr.argument).toJavaReferenceType
-		val argCode = expr.argument.javaCode(Mapper.wrapExtends(argItemType), context.scope)
+		val argCode = expr.argument.javaCode(MAPPER.wrapExtends(argItemType), context.scope)
 		val argType = argCode.expressionType
 		argCode
-			.applyRuntimeMethod('distinct', argType.hasWildcardArgument ? MapperC.wrapExtends(argItemType) : MapperC.wrap(argItemType))
+			.applyRuntimeMethod('distinct', argType.hasWildcardArgument ? MAPPER_C.wrapExtends(argItemType) : MAPPER_C.wrap(argItemType))
 	}
 
 	override protected caseDivideOperation(ArithmeticOperation expr, Context context) {
@@ -633,7 +632,7 @@ class ExpressionGenerator extends RosettaExpressionSwitch<JavaStatementBuilder,
 				'multipleExists'
 			else
 				'exists'
-		expr.argument.javaCode(Mapper.wrapExtends(expr.argument), context.scope)
+		expr.argument.javaCode(MAPPER.wrapExtends(expr.argument), context.scope)
 			.applyRuntimeMethod(methodName, COMPARISON_RESULT)
 	}
 
@@ -643,14 +642,14 @@ class ExpressionGenerator extends RosettaExpressionSwitch<JavaStatementBuilder,
 			(expr.eContainer as RosettaFeatureCall).feature instanceof RosettaMetaType) {
 			autoValue = false;
 		}
-		return featureCall(expr.receiver.javaCode(Mapper.wrapExtends(expr.receiver), context.scope), typeProvider.getRType(expr.receiver), expr.feature, context.scope, autoValue)
+		return featureCall(expr.receiver.javaCode(MAPPER.wrapExtends(expr.receiver), context.scope), typeProvider.getRType(expr.receiver), expr.feature, context.scope, autoValue)
 	}
 
 	override protected caseFilterOperation(FilterOperation expr, Context context) {
 		val StringConcatenationClient inlineFunctionCode = expr.function.inlineFunction(JavaPrimitiveType.BOOLEAN.toReferenceType, context.scope).key
 		if (!expr.isPreviousOperationMulti) {
 			// Case MapperS
-			val argCode = expr.argument.javaCode(MapperS.wrapExtends(expr.argument), context.scope)
+			val argCode = expr.argument.javaCode(MAPPER_S.wrapExtends(expr.argument), context.scope)
 				.collapseToSingleExpression(context.scope)
 			argCode
 				.mapExpression[JavaExpression.from(
@@ -662,7 +661,7 @@ class ExpressionGenerator extends RosettaExpressionSwitch<JavaStatementBuilder,
 		} else {
 			if (expr.argument.isOutputListOfLists) {
 				// Case MapperListOfLists
-				val argCode = expr.argument.javaCode(MapperListOfLists.wrapExtends(expr.argument), context.scope)
+				val argCode = expr.argument.javaCode(MAPPER_LIST_OF_LISTS.wrapExtends(expr.argument), context.scope)
 					.collapseToSingleExpression(context.scope)
 				argCode
 					.mapExpression[JavaExpression.from(
@@ -673,7 +672,7 @@ class ExpressionGenerator extends RosettaExpressionSwitch<JavaStatementBuilder,
 					)]
 			} else {
 				// Case MapperC
-				val argCode = expr.argument.javaCode(MapperC.wrapExtends(expr.argument), context.scope)
+				val argCode = expr.argument.javaCode(MAPPER_C.wrapExtends(expr.argument), context.scope)
 					.collapseToSingleExpression(context.scope)
 				argCode
 					.mapExpression[JavaExpression.from(
@@ -687,11 +686,11 @@ class ExpressionGenerator extends RosettaExpressionSwitch<JavaStatementBuilder,
 	}
 
 	override protected caseFirstOperation(FirstOperation expr, Context context) {
-		buildListOperationNoBody(expr, "first", MapperC.wrapExtends(expr.argument), [MapperS.wrap(it.itemType)], context.scope)
+		buildListOperationNoBody(expr, "first", MAPPER_C.wrapExtends(expr.argument), [MAPPER_S.wrap(it.itemType)], context.scope)
 	}
 
 	override protected caseFlattenOperation(FlattenOperation expr, Context context) {
-		buildListOperationNoBody(expr, "flattenList", MapperListOfLists.wrapExtends(expr.argument), [it.hasWildcardArgument ? MapperC.wrapExtends(expr.argument) : MapperC.wrap(expr.argument)], context.scope)
+		buildListOperationNoBody(expr, "flattenList", MAPPER_LIST_OF_LISTS.wrapExtends(expr.argument), [it.hasWildcardArgument ? MAPPER_C.wrapExtends(expr.argument) : MAPPER_C.wrap(expr.argument)], context.scope)
 	}
 
 	override protected caseGreaterThanOperation(ComparisonOperation expr, Context context) {
@@ -723,7 +722,7 @@ class ExpressionGenerator extends RosettaExpressionSwitch<JavaStatementBuilder,
 	}
 
 	override protected caseLastOperation(LastOperation expr, Context context) {
-		buildListOperationNoBody(expr, "last", MapperC.wrapExtends(expr.argument), [MapperS.wrap(it.itemType)], context.scope)
+		buildListOperationNoBody(expr, "last", MAPPER_C.wrapExtends(expr.argument), [MAPPER_S.wrap(it.itemType)], context.scope)
 	}
 
 	override protected caseLessThanOperation(ComparisonOperation expr, Context context) {
@@ -740,11 +739,11 @@ class ExpressionGenerator extends RosettaExpressionSwitch<JavaStatementBuilder,
 		}
 		val itemType = typeProvider.getRType(expr).toJavaReferenceType
 		val first = expr.elements.head
-		var elementsCode = first.javaCode(first.isMulti ? MapperC.wrapExtends(itemType) : MapperS.wrapExtends(itemType), context.scope)
+		var elementsCode = first.javaCode(first.isMulti ? MAPPER_C.wrapExtends(itemType) as JavaType : MAPPER_S.wrapExtends(itemType), context.scope)
 		for (var i = 1; i < expr.elements.size; i++) {
 			val elem = expr.elements.get(i)
 			elementsCode = elementsCode.then(
-				elem.javaCode(elem.isMulti ? MapperC.wrapExtends(itemType) : MapperS.wrapExtends(itemType), context.scope),
+				elem.javaCode(elem.isMulti ? MAPPER_C.wrapExtends(itemType) as JavaType : MAPPER_S.wrapExtends(itemType), context.scope),
 				[elemList, newElem|JavaExpression.from('''«elemList», «newElem»''', null)],
 				context.scope
 			)
@@ -754,7 +753,7 @@ class ExpressionGenerator extends RosettaExpressionSwitch<JavaStatementBuilder,
 			.mapExpression[
 				JavaExpression.from(
 					'''«MapperC».<«itemType»>of(«it»)''',
-					MapperC.wrap(itemType)
+					MAPPER_C.wrap(itemType)
 				)
 			]
 	}
@@ -766,10 +765,10 @@ class ExpressionGenerator extends RosettaExpressionSwitch<JavaStatementBuilder,
 		if (!expr.isPreviousOperationMulti) {
 			if (isBodyMulti) {
 				// Case MapperS to MapperC
-				val inlineFunctionCodeAndBodyType = expr.function.inlineFunction(MapperC.wrapExtends(bodyItemType), context.scope)
+				val inlineFunctionCodeAndBodyType = expr.function.inlineFunction(MAPPER_C.wrapExtends(bodyItemType), context.scope)
 				val StringConcatenationClient inlineFunctionCode = inlineFunctionCodeAndBodyType.key
 				val inlineFunctionBodyType = inlineFunctionCodeAndBodyType.value
-				expr.argument.javaCode(MapperS.wrapExtends(expr.argument), context.scope)
+				expr.argument.javaCode(MAPPER_S.wrapExtends(expr.argument), context.scope)
 					.collapseToSingleExpression(context.scope)
 					.mapExpression[JavaExpression.from(
 						'''
@@ -779,67 +778,67 @@ class ExpressionGenerator extends RosettaExpressionSwitch<JavaStatementBuilder,
 					)]
 			} else {
 				// Case MapperS to MapperS
-				buildSingleItemListOperationOptionalBody(expr, "mapSingleToItem", MapperS.wrapExtends(expr.argument), MapperS.wrapExtends(bodyItemType), [a,b|b], context.scope)
+				buildSingleItemListOperationOptionalBody(expr, "mapSingleToItem", MAPPER_S.wrapExtends(expr.argument), MAPPER_S.wrapExtends(bodyItemType), [a,b|b], context.scope)
 			}
 		} else {
 			if (expr.argument.isOutputListOfLists) {
 				if (isBodyMulti) {
 					// Case MapperListOfLists to MapperListOfLists
-					val inlineFunctionCodeAndBodyType = expr.function.inlineFunction(MapperC.wrapExtends(bodyItemType), context.scope)
+					val inlineFunctionCodeAndBodyType = expr.function.inlineFunction(MAPPER_C.wrapExtends(bodyItemType), context.scope)
 					val StringConcatenationClient inlineFunctionCode = inlineFunctionCodeAndBodyType.key
 					val inlineFunctionBodyType = inlineFunctionCodeAndBodyType.value
-					expr.argument.javaCode(MapperListOfLists.wrapExtends(expr.argument), context.scope)
+					expr.argument.javaCode(MAPPER_LIST_OF_LISTS.wrapExtends(expr.argument), context.scope)
 						.collapseToSingleExpression(context.scope)
 						.mapExpression[JavaExpression.from(
 							'''
 							«it»
 								.mapListToList(«inlineFunctionCode»)''',
-							inlineFunctionBodyType.hasWildcardArgument ? MapperListOfLists.wrapExtends(bodyItemType) : MapperListOfLists.wrap(bodyItemType)
+							inlineFunctionBodyType.hasWildcardArgument ? MAPPER_LIST_OF_LISTS.wrapExtends(bodyItemType) : MAPPER_LIST_OF_LISTS.wrap(bodyItemType)
 						)]
 				} else {
 					// Case MapperListOfLists to MapperC
-					val inlineFunctionCodeAndBodyType = expr.function.inlineFunction(MapperS.wrapExtends(bodyItemType), context.scope)
+					val inlineFunctionCodeAndBodyType = expr.function.inlineFunction(MAPPER_S.wrapExtends(bodyItemType), context.scope)
 					val StringConcatenationClient inlineFunctionCode = inlineFunctionCodeAndBodyType.key
 					val inlineFunctionBodyType = inlineFunctionCodeAndBodyType.value
-					expr.argument.javaCode(MapperListOfLists.wrapExtends(expr.argument), context.scope)
+					expr.argument.javaCode(MAPPER_LIST_OF_LISTS.wrapExtends(expr.argument), context.scope)
 						.collapseToSingleExpression(context.scope)
 						.mapExpression[JavaExpression.from(
 							'''
 							«it»
 								.mapListToItem(«inlineFunctionCode»)''',
-							inlineFunctionBodyType.hasWildcardArgument ? MapperC.wrapExtends(bodyItemType) : MapperC.wrap(bodyItemType)
+							inlineFunctionBodyType.hasWildcardArgument ? MAPPER_C.wrapExtends(bodyItemType) : MAPPER_C.wrap(bodyItemType)
 						)]
 				}
 			} else {
 				if (isBodyMulti) {
 					// MapperC to MapperListOfLists
-					val inlineFunctionCodeAndBodyType = expr.function.inlineFunction(MapperC.wrapExtends(bodyItemType), context.scope)
+					val inlineFunctionCodeAndBodyType = expr.function.inlineFunction(MAPPER_C.wrapExtends(bodyItemType), context.scope)
 					val StringConcatenationClient inlineFunctionCode = inlineFunctionCodeAndBodyType.key
 					val inlineFunctionBodyType = inlineFunctionCodeAndBodyType.value
-					expr.argument.javaCode(MapperC.wrapExtends(expr.argument), context.scope)
+					expr.argument.javaCode(MAPPER_C.wrapExtends(expr.argument), context.scope)
 						.collapseToSingleExpression(context.scope)
 						.mapExpression[JavaExpression.from(
 							'''
 							«it»
 								.mapItemToList(«inlineFunctionCode»)''',
-							inlineFunctionBodyType.hasWildcardArgument ? MapperListOfLists.wrapExtends(bodyItemType) : MapperListOfLists.wrap(bodyItemType)
+							inlineFunctionBodyType.hasWildcardArgument ? MAPPER_LIST_OF_LISTS.wrapExtends(bodyItemType) : MAPPER_LIST_OF_LISTS.wrap(bodyItemType)
 						)]
 				} else {
 					// MapperC to MapperC
-					buildSingleItemListOperationOptionalBody(expr, "mapItem", MapperC.wrapExtends(expr.argument), MapperS.wrapExtends(bodyItemType), [a,b|b.hasWildcardArgument ? MapperC.wrapExtends(bodyItemType) : MapperC.wrap(bodyItemType)], context.scope)
+					buildSingleItemListOperationOptionalBody(expr, "mapItem", MAPPER_C.wrapExtends(expr.argument), MAPPER_S.wrapExtends(bodyItemType), [a,b|b.hasWildcardArgument ? MAPPER_C.wrapExtends(bodyItemType) : MAPPER_C.wrap(bodyItemType)], context.scope)
 				}
 			}
 		}
 	}
 
 	override protected caseMaxOperation(MaxOperation expr, Context context) {
-		val bodyType = if (expr.function !== null) MapperS.wrapExtends(expr.function.body)
-		buildSingleItemListOperationOptionalBody(expr, "max", MapperC.wrapExtends(expr.argument), bodyType, [a,b|MapperS.wrap(a.itemType)], context.scope)
+		val bodyType = if (expr.function !== null) MAPPER_S.wrapExtends(expr.function.body)
+		buildSingleItemListOperationOptionalBody(expr, "max", MAPPER_C.wrapExtends(expr.argument), bodyType, [a,b|MAPPER_S.wrap(a.itemType)], context.scope)
 	}
 
 	override protected caseMinOperation(MinOperation expr, Context context) {
-		val bodyType = if (expr.function !== null) MapperS.wrapExtends(expr.function.body)
-		buildSingleItemListOperationOptionalBody(expr, "min", MapperC.wrapExtends(expr.argument), bodyType, [a,b|MapperS.wrap(a.itemType)], context.scope)
+		val bodyType = if (expr.function !== null) MAPPER_S.wrapExtends(expr.function.body)
+		buildSingleItemListOperationOptionalBody(expr, "min", MAPPER_C.wrapExtends(expr.argument), bodyType, [a,b|MAPPER_S.wrap(a.itemType)], context.scope)
 	}
 
 	override protected caseMultiplyOperation(ArithmeticOperation expr, Context context) {
@@ -865,7 +864,7 @@ class ExpressionGenerator extends RosettaExpressionSwitch<JavaStatementBuilder,
 	}
 
 	override protected caseOnlyExists(RosettaOnlyExistsExpression expr, Context context) {
-		expr.args.map[it.javaCode(Mapper.wrapExtends(it), context.scope)]
+		expr.args.map[it.javaCode(MAPPER.wrapExtends(it), context.scope)]
 			.reduce[acc, stat| acc.then(stat, [list, item| JavaExpression.from('''«list», «item»''', null)], context.scope)]
 			.mapExpression[JavaExpression.from('''«runtimeMethod('onlyExists')»(«Arrays».asList(«it»))''', COMPARISON_RESULT)]
 	}
@@ -876,10 +875,10 @@ class ExpressionGenerator extends RosettaExpressionSwitch<JavaStatementBuilder,
 
 	override protected caseReduceOperation(ReduceOperation expr, Context context) {
 		val outputType = typeProvider.getRType(expr.function.body).toJavaReferenceType
-		val inlineFunctionCodeAndBodyType = expr.function.inlineFunction(MapperS.wrapExtends(outputType), context.scope)
+		val inlineFunctionCodeAndBodyType = expr.function.inlineFunction(MAPPER_S.wrapExtends(outputType), context.scope)
 		val StringConcatenationClient inlineFunctionCode = inlineFunctionCodeAndBodyType.key
 		val inlineFunctionBodyType = inlineFunctionCodeAndBodyType.value
-		expr.argument.javaCode(MapperC.wrapExtends(expr.argument), context.scope)
+		expr.argument.javaCode(MAPPER_C.wrapExtends(expr.argument), context.scope)
 			.collapseToSingleExpression(context.scope)
 			.mapExpression[JavaExpression.from(
 				'''
@@ -890,12 +889,12 @@ class ExpressionGenerator extends RosettaExpressionSwitch<JavaStatementBuilder,
 	}
 
 	override protected caseReverseOperation(ReverseOperation expr, Context context) {
-		buildListOperationNoBody(expr, "reverse", MapperC.wrapExtends(expr.argument), [it], context.scope)
+		buildListOperationNoBody(expr, "reverse", MAPPER_C.wrapExtends(expr.argument), [it], context.scope)
 	}
 
 	override protected caseSortOperation(SortOperation expr, Context context) {
-		val bodyType = if (expr.function !== null) MapperS.wrapExtends(expr.function.body)
-		buildSingleItemListOperationOptionalBody(expr, "sort", MapperC.wrapExtends(expr.argument), bodyType, [a,b|a], context.scope)
+		val bodyType = if (expr.function !== null) MAPPER_S.wrapExtends(expr.function.body)
+		buildSingleItemListOperationOptionalBody(expr, "sort", MAPPER_C.wrapExtends(expr.argument), bodyType, [a,b|a], context.scope)
 	}
 
 	override protected caseStringLiteral(RosettaStringLiteral expr, Context context) {
@@ -908,7 +907,7 @@ class ExpressionGenerator extends RosettaExpressionSwitch<JavaStatementBuilder,
 
 	override protected caseSumOperation(SumOperation expr, Context context) {
 		val itemType = typeProvider.getRType(expr.argument).toJavaReferenceType
-		buildListOperationNoBody(expr, "sum" + itemType.simpleName, MapperC.wrapExtends(itemType), [MapperS.wrap(itemType)], context.scope)
+		buildListOperationNoBody(expr, "sum" + itemType.simpleName, MAPPER_C.wrapExtends(itemType), [MAPPER_S.wrap(itemType)], context.scope)
 	}
 
 	override protected caseSymbolReference(RosettaSymbolReference expr, Context context) {
@@ -936,10 +935,10 @@ class ExpressionGenerator extends RosettaExpressionSwitch<JavaStatementBuilder,
 				val shortcut = rObjectFactory.buildRShortcut(s)
 				val itemType = typeProvider.getRTypeOfSymbol(s).toJavaReferenceType
 				if (exprHelper.usesOutputParameter(s.expression)) {
-					val aliasType = isMulti ? List.wrap(itemType) : itemType
+					val aliasType = isMulti ? LIST.wrap(itemType) : itemType
 					JavaExpression.from('''«context.scope.getIdentifierOrThrow(shortcut)»(«aliasCallArgs(s, context.scope)»).build()''', aliasType)
 				} else {
-					val aliasType = isMulti ? MapperC.wrapExtendsIfNotFinal(itemType) : MapperS.wrapExtendsIfNotFinal(itemType)
+					val aliasType = isMulti ? MAPPER_C.wrapExtendsIfNotFinal(itemType) as JavaType : MAPPER_S.wrapExtendsIfNotFinal(itemType)
 					JavaExpression.from('''«context.scope.getIdentifierOrThrow(shortcut)»(«aliasCallArgs(s, context.scope)»)''', aliasType)
 				}
 				
@@ -949,7 +948,7 @@ class ExpressionGenerator extends RosettaExpressionSwitch<JavaStatementBuilder,
 				JavaExpression.from('''«t»''', t)
 			}
 			ClosureParameter: {
-				new JavaVariable(context.scope.getIdentifierOrThrow(s), expr.isMulti ? MapperC.wrap(expr) : MapperS.wrap(expr))
+				new JavaVariable(context.scope.getIdentifierOrThrow(s), expr.isMulti ? MAPPER_C.wrap(expr) as JavaType : MAPPER_S.wrap(expr))
 			}
 			RosettaCallableWithArgs: {
 				callableWithArgsCall(s, expr.args, context.scope)
@@ -960,7 +959,7 @@ class ExpressionGenerator extends RosettaExpressionSwitch<JavaStatementBuilder,
 	}
 
 	override protected caseThenOperation(ThenOperation expr, Context context) {
-		val thenArgCode = expr.argument.javaCode(expr.argument.isMulti ? MapperC.wrapExtends(expr.argument) : MapperS.wrapExtends(expr.argument), context.scope)
+		val thenArgCode = expr.argument.javaCode(expr.argument.isMulti ? MAPPER_C.wrapExtends(expr.argument) as JavaType : MAPPER_S.wrapExtends(expr.argument), context.scope)
 		val thenAsVarCode = thenArgCode.declareAsVariable(true, "thenResult", context.scope)
 		if (expr.function.parameters.size == 0) {
 			context.scope.createKeySynonym(expr.function.implicitVarInContext, thenArgCode)
@@ -969,16 +968,16 @@ class ExpressionGenerator extends RosettaExpressionSwitch<JavaStatementBuilder,
 		}
 		thenAsVarCode
 			.then(
-				expr.function.body.javaCode(expr.isMulti ? MapperC.wrapExtends(expr) : MapperS.wrapExtends(expr), context.scope),
+				expr.function.body.javaCode(expr.isMulti ? MAPPER_C.wrapExtends(expr) as JavaType : MAPPER_S.wrapExtends(expr), context.scope),
 				[a, b| b],
 				context.scope
 			)
 	}
 
 	private def JavaStatementBuilder conversionOperation(RosettaUnaryOperation expr, Context context, StringConcatenationClient conversion, Class<? extends Exception> errorClass) {
-		expr.argument.javaCode(MapperS.wrapExtends(expr.argument), context.scope)
+		expr.argument.javaCode(MAPPER_S.wrapExtends(expr.argument), context.scope)
 			.collapseToSingleExpression(context.scope)
-			.mapExpression[JavaExpression.from('''«it».checkedMap("«expr.operator»", «conversion», «errorClass».class)''', MapperS.wrap(expr))]
+			.mapExpression[JavaExpression.from('''«it».checkedMap("«expr.operator»", «conversion», «errorClass».class)''', MAPPER_S.wrap(expr))]
 	}
 
 	override protected caseToEnumOperation(ToEnumOperation expr, Context context) {
@@ -1001,9 +1000,9 @@ class ExpressionGenerator extends RosettaExpressionSwitch<JavaStatementBuilder,
 		} else {
 			'''«Object»::toString'''
 		}
-		expr.argument.javaCode(MapperS.wrapExtends(expr.argument), context.scope)
+		expr.argument.javaCode(MAPPER_S.wrapExtends(expr.argument), context.scope)
 			.collapseToSingleExpression(context.scope)
-			.mapExpression[JavaExpression.from('''«it».map("«expr.operator»", «toStringMethod»)''', MapperS.wrap(expr))]
+			.mapExpression[JavaExpression.from('''«it».map("«expr.operator»", «toStringMethod»)''', MAPPER_S.wrap(expr))]
 	}
 
 	override protected caseToTimeOperation(ToTimeOperation expr, Context context) {
@@ -1056,7 +1055,7 @@ class ExpressionGenerator extends RosettaExpressionSwitch<JavaStatementBuilder,
 			if (isMulti) {
 				val lambdaScope = scope.lambdaScope
 				val item = lambdaScope.createUniqueIdentifier("item")
-				value.javaCode(MapperC.wrapExtends(value), scope)
+				value.javaCode(MAPPER_C.wrapExtends(value), scope)
 					.collapseToSingleExpression(scope)
 					.mapExpression[
 						JavaExpression.from(
@@ -1068,7 +1067,7 @@ class ExpressionGenerator extends RosettaExpressionSwitch<JavaStatementBuilder,
 										.setGlobalReference(«item».getMappedObject().getMeta().getGlobalKey())
 										.build())
 									.collect(«Collectors».toList())''',
-							List.wrap(metaClass)
+							LIST.wrap(metaClass)
 						)
 					]
 			} else {
@@ -1096,7 +1095,7 @@ class ExpressionGenerator extends RosettaExpressionSwitch<JavaStatementBuilder,
 			}
 		} else {
 			val clazz = typeProvider.getRTypeOfFeature(feature).toJavaReferenceType
-			value.javaCode(isMulti ? List.wrap(clazz) : clazz, scope)
+			value.javaCode(isMulti ? LIST.wrap(clazz) : clazz, scope)
 		}
 	}
 }
diff --git a/rosetta-lang/src/main/java/com/regnosys/rosetta/generator/java/expression/TypeCoercionService.xtend b/rosetta-lang/src/main/java/com/regnosys/rosetta/generator/java/expression/TypeCoercionService.xtend
index 8569eb69c..ea565151b 100644
--- a/rosetta-lang/src/main/java/com/regnosys/rosetta/generator/java/expression/TypeCoercionService.xtend
+++ b/rosetta-lang/src/main/java/com/regnosys/rosetta/generator/java/expression/TypeCoercionService.xtend
@@ -4,14 +4,12 @@ import com.rosetta.util.types.JavaType
 import java.math.BigInteger
 import java.math.BigDecimal
 import com.regnosys.rosetta.generator.java.JavaScope
-import java.util.List
 import java.util.Optional
 import java.util.Collections
 import java.util.stream.Collectors
 import com.rosetta.model.lib.mapper.MapperS
 import com.rosetta.model.lib.mapper.MapperC
 import com.rosetta.model.lib.expression.ComparisonResult
-import com.rosetta.model.lib.mapper.MapperListOfLists
 import java.util.function.Function
 import com.regnosys.rosetta.generator.java.statement.builder.JavaStatementBuilder
 import com.regnosys.rosetta.generator.java.statement.builder.JavaExpression
@@ -242,7 +240,7 @@ class TypeCoercionService {
 			if (actual.isComparisonResult) {
 				if (expected.isMapperS) {
 					// Case ComparisonResult to MapperS
-					[JavaExpression.from('''«it».asMapper()''', MapperS.wrap(BOOLEAN))]
+					[JavaExpression.from('''«it».asMapper()''', MAPPER_S.wrap(BOOLEAN))]
 				} else if (expected.isMapperC) {
 					// Case ComparisonResult to MapperC
 					// Not handled
@@ -251,7 +249,7 @@ class TypeCoercionService {
 					// Not handled
 				} else if (expected.isList) {
 					// Case ComparisonResult to List
-					[JavaExpression.from('''«it».getMulti()''', List.wrap(BOOLEAN))]
+					[JavaExpression.from('''«it».getMulti()''', LIST.wrap(BOOLEAN))]
 				}
 			} else if (actual.extendsMapper) {
 				if (expected.isComparisonResult) {
@@ -260,16 +258,16 @@ class TypeCoercionService {
 				} else if (expected.extendsMapper) {
 					if (actual.isMapperS && actual.hasWildcardArgument && expected.isMapperS && !expected.hasWildcardArgument) {
 						// Case immutable MapperS<? extends T> to mutable MapperS<T>
-						[JavaExpression.from('''«it».map("Make mutable", «Function».identity())''', MapperS.wrap(expected.itemType))]
+						[JavaExpression.from('''«it».map("Make mutable", «Function».identity())''', MAPPER_S.wrap(expected.itemType))]
 					} else if (actual.isMapperC && actual.hasWildcardArgument && expected.isMapperC && !expected.hasWildcardArgument) {
 						// Case immutable MapperC<? extends T> to mutable MapperC<T>
-						[JavaExpression.from('''«it».map("Make mutable", «Function».identity())''', MapperC.wrap(expected.itemType))]
+						[JavaExpression.from('''«it».map("Make mutable", «Function».identity())''', MAPPER_C.wrap(expected.itemType))]
 					} else if (actual.isMapperS && expected.isMapperC) {
 						// Case MapperS to MapperC
-						[JavaExpression.from('''«MapperC».of(«it»)''', MapperC.wrap(expected.itemType))]
+						[JavaExpression.from('''«MapperC».of(«it»)''', MAPPER_C.wrap(expected.itemType))]
 					} else if (actual.isMapperC && expected.isMapperS) {
 						// Case MapperC to MapperS
-						[JavaExpression.from('''«MapperS».of(«it».get())''', MapperS.wrap(expected.itemType))]
+						[JavaExpression.from('''«MapperS».of(«it».get())''', MAPPER_S.wrap(expected.itemType))]
 					}
 				} else if (expected.isMapperListOfLists) {
 					// Case Mapper to MapperListOfLists
@@ -277,9 +275,9 @@ class TypeCoercionService {
 				} else if (expected.isList) {
 					// Case Mapper to List
 					if (actual.hasWildcardArgument && !expected.hasWildcardArgument) {
-						[JavaExpression.from('''new «ArrayList»<>(«it».getMulti())''', List.wrap(expected.itemType))]
+						[JavaExpression.from('''new «ArrayList»<>(«it».getMulti())''', LIST.wrap(expected.itemType))]
 					} else {
-						[JavaExpression.from('''«it».getMulti()''', List.wrap(expected.itemType))]
+						[JavaExpression.from('''«it».getMulti()''', LIST.wrap(expected.itemType))]
 					}
 				}
 			} else if (actual.isMapperListOfLists) {
@@ -290,16 +288,16 @@ class TypeCoercionService {
 					[JavaExpression.from('''«ComparisonResult».of(«MapperC».of(«it»))''', COMPARISON_RESULT)]
 				} else if (expected.isMapperS) {
 					// Case List to MapperS
-					[JavaExpression.from('''«MapperS».of(«it».get(0))''', MapperS.wrap(expected.itemType))]
+					[JavaExpression.from('''«MapperS».of(«it».get(0))''', MAPPER_S.wrap(expected.itemType))]
 				} else if (expected.isMapperC || expected.isMapper) {
 					// Case List to MapperC/Mapper
-					[JavaExpression.from('''«MapperC».<«expected.itemType»>of(«it»)''', MapperC.wrap(expected.itemType))]
+					[JavaExpression.from('''«MapperC».<«expected.itemType»>of(«it»)''', MAPPER_C.wrap(expected.itemType))]
 				} else if (expected.isMapperListOfLists) {
 					// Case List to MapperListOfLists
 					// Not handled
 				} else if (expected.isList && actual.hasWildcardArgument && !expected.hasWildcardArgument) {
 					// Case immutable List<? extends T> to mutable List<T>
-					[JavaExpression.from('''new «ArrayList»(«it»)''', List.wrap(expected.itemType))]
+					[JavaExpression.from('''new «ArrayList»(«it»)''', LIST.wrap(expected.itemType))]
 				}
 			}
 		)
@@ -322,11 +320,11 @@ class TypeCoercionService {
 	private def JavaExpression empty(JavaType expected) {
 		val itemType = expected.itemType
 		if (expected.isList) {
-			JavaExpression.from('''«Collections».<«itemType»>emptyList()''', List.wrap(itemType))
+			JavaExpression.from('''«Collections».<«itemType»>emptyList()''', LIST.wrap(itemType))
 		} else if (expected.isMapperS || expected.isMapper) {
-			JavaExpression.from('''«MapperS».<«itemType»>ofNull()''', MapperS.wrap(itemType))
+			JavaExpression.from('''«MapperS».<«itemType»>ofNull()''', MAPPER_S.wrap(itemType))
 		} else if (expected.isMapperC) {
-			JavaExpression.from('''«MapperC».<«itemType»>ofNull()''', MapperC.wrap(itemType))
+			JavaExpression.from('''«MapperC».<«itemType»>ofNull()''', MAPPER_C.wrap(itemType))
 		} else if (expected.isComparisonResult) {
 			JavaExpression.from('''«ComparisonResult».successEmptyOperand("")''', COMPARISON_RESULT)
 		} else if (expected == JavaPrimitiveType.BOOLEAN) {
@@ -408,13 +406,13 @@ class TypeCoercionService {
 		}
 	}
 	private def JavaExpression getItemToListConversionExpression(JavaExpression expression) {
-		JavaExpression.from('''«Collections».singletonList(«expression»)''', List.wrap(expression.expressionType))
+		JavaExpression.from('''«Collections».singletonList(«expression»)''', LIST.wrap(expression.expressionType))
 	}
 	private def JavaExpression getItemToMapperSConversionExpression(JavaExpression expression) {
-		JavaExpression.from('''«MapperS».of(«expression»)''', MapperS.wrap(expression.expressionType))
+		JavaExpression.from('''«MapperS».of(«expression»)''', MAPPER_S.wrap(expression.expressionType))
 	}
 	private def JavaExpression getItemToMapperCConversionExpression(JavaExpression expression) {
-		JavaExpression.from('''«MapperC».of(«Collections».singletonList(«expression»))''', MapperC.wrap(expression.expressionType))
+		JavaExpression.from('''«MapperC».of(«Collections».singletonList(«expression»))''', MAPPER_C.wrap(expression.expressionType))
 	}
 	private def JavaExpression getItemToComparisonResultConversionExpression(JavaExpression expression) {
 		JavaExpression.from('''«ComparisonResult».of(«MapperS».of(«expression»))''', COMPARISON_RESULT)
@@ -436,7 +434,7 @@ class TypeCoercionService {
 				.<«resultItem.expressionType»>map(«lambdaParam» -> «resultItem»)
 				.collect(«Collectors».toList())
 			''',
-			List.wrap(resultItem.expressionType)
+			LIST.wrap(resultItem.expressionType)
 		)
 	}
 	private def JavaExpression getMapperSItemConversionExpression(JavaExpression expression, Function<JavaExpression, JavaExpression> itemConversion, JavaScope scope) {
@@ -444,7 +442,7 @@ class TypeCoercionService {
 		val lambdaScope = scope.lambdaScope
 		val lambdaParam = lambdaScope.createUniqueIdentifier(actualItemType.simpleName.toFirstLower)
 		val resultItem = itemConversion.apply(new JavaVariable(lambdaParam, actualItemType))
-		val resultType = MapperS.wrap(resultItem.expressionType)
+		val resultType = MAPPER_S.wrap(resultItem.expressionType)
 		JavaExpression.from(
 			'''«expression».<«resultType.itemType»>map("Type coercion", «lambdaParam» -> «lambdaParam» == null ? null : «resultItem»)''',
 			resultType
@@ -455,7 +453,7 @@ class TypeCoercionService {
 		val lambdaScope = scope.lambdaScope
 		val lambdaParam = lambdaScope.createUniqueIdentifier(actualItemType.simpleName.toFirstLower)
 		val resultItem = itemConversion.apply(new JavaVariable(lambdaParam, actualItemType))
-		val resultType = MapperC.wrap(resultItem.expressionType)
+		val resultType = MAPPER_C.wrap(resultItem.expressionType)
 		JavaExpression.from(
 			'''«expression».<«resultType.itemType»>map("Type coercion", «lambdaParam» -> «resultItem»)''',
 			resultType
@@ -465,8 +463,8 @@ class TypeCoercionService {
 		val actualItemType = expression.expressionType.itemType
 		val listToListLambdaScope = scope.lambdaScope
 		val mapperCParam = listToListLambdaScope.createUniqueIdentifier("mapperC")
-		val resultMapperC = getMapperCItemConversionExpression(new JavaVariable(mapperCParam, MapperC.wrap(actualItemType)), itemConversion, listToListLambdaScope)
-		val resultType = MapperListOfLists.wrap(resultMapperC.expressionType.itemType)
+		val resultMapperC = getMapperCItemConversionExpression(new JavaVariable(mapperCParam, MAPPER_C.wrap(actualItemType)), itemConversion, listToListLambdaScope)
+		val resultType = MAPPER_LIST_OF_LISTS.wrap(resultMapperC.expressionType.itemType)
 		JavaExpression.from(
 			'''«expression».<«resultType.itemType»>mapListToList(«mapperCParam» -> «resultMapperC»)''',
 			resultType
diff --git a/rosetta-lang/src/main/java/com/regnosys/rosetta/generator/java/function/FunctionGenerator.xtend b/rosetta-lang/src/main/java/com/regnosys/rosetta/generator/java/function/FunctionGenerator.xtend
index 678b4c32b..c48fa316a 100644
--- a/rosetta-lang/src/main/java/com/regnosys/rosetta/generator/java/function/FunctionGenerator.xtend
+++ b/rosetta-lang/src/main/java/com/regnosys/rosetta/generator/java/function/FunctionGenerator.xtend
@@ -63,13 +63,13 @@ import com.rosetta.model.lib.ModelSymbolId
 import com.rosetta.util.types.JavaReferenceType
 import com.regnosys.rosetta.generator.java.statement.builder.JavaExpression
 import com.regnosys.rosetta.generator.java.statement.builder.JavaStatementBuilder
-import com.rosetta.model.lib.mapper.MapperC
 import com.regnosys.rosetta.generator.java.statement.JavaStatement
 import com.regnosys.rosetta.generator.java.types.JavaTypeUtil
-import com.rosetta.model.lib.mapper.MapperS
 import com.rosetta.util.types.generated.GeneratedJavaClass
 import com.regnosys.rosetta.generator.java.expression.TypeCoercionService
 import java.util.Collections
+import com.fasterxml.jackson.core.type.TypeReference
+import com.rosetta.util.types.JavaGenericTypeDeclaration
 
 class FunctionGenerator {
 
@@ -119,7 +119,7 @@ class FunctionGenerator {
 	
 	private def getQualifyingFunctionInterface(List<RAttribute> inputs) {
 		val parameterVariable = inputs.head.RType.toListOrSingleJavaType(inputs.head.multi)
-		JavaParameterizedType.from(IQualifyFunctionExtension, parameterVariable)
+		JavaParameterizedType.from(new TypeReference<IQualifyFunctionExtension<?>>() {}, parameterVariable)
 	}
 
 	private def collectFunctionDependencies(Function func) {
@@ -277,7 +277,7 @@ class FunctionGenerator {
 						protected abstract «IF multi»«List»<«returnType»>«ELSE»«returnType»«ENDIF» «classScope.getIdentifierOrThrow(alias)»(«output.toBuilderType» «aliasScope.getIdentifierOrThrow(output)», «IF !inputs.empty»«inputs.inputsAsParameters(aliasScope)»«ENDIF»);
 				«ELSE»
 					«val multi = cardinality.isMulti(alias.expression)»
-					«val returnType = (multi ? MapperC as Class<?> : MapperS).wrapExtendsIfNotFinal(alias.expression)»
+					«val returnType = (multi ? MAPPER_C as JavaGenericTypeDeclaration<?> : MAPPER_S).wrapExtendsIfNotFinal(alias.expression)»
 					
 						protected abstract «returnType» «classScope.getIdentifierOrThrow(alias)»(«inputs.inputsAsParameters(aliasScope)»);
 				«ENDIF»
@@ -309,7 +309,7 @@ class FunctionGenerator {
 						«IF aliasOut.get(alias)»
 							«val multi = cardinality.isMulti(alias.expression)»
 							«val itemReturnType = shortcutJavaType(alias)»
-							«val returnType = multi ? List.wrap(itemReturnType) : itemReturnType»
+							«val returnType = multi ? LIST.wrap(itemReturnType) : itemReturnType»
 							«val body = expressionGenerator.javaCode(alias.expression, alias.shortcutExpressionJavaType, aliasScope)
 									.mapExpressionIfNotNull[JavaExpression.from('''toBuilder(«it»)''', returnType)]
 							»
@@ -318,7 +318,7 @@ class FunctionGenerator {
 							protected «returnType» «classScope.getIdentifierOrThrow(alias)»(«output.toBuilderType» «aliasScope.getIdentifierOrThrow(output)», «IF !inputs.empty»«inputs.inputsAsParameters(aliasScope)»«ENDIF») «body.completeAsReturn.toBlock»
 						«ELSE»
 							«val multi = cardinality.isMulti(alias.expression)»
-							«val returnType = (multi ? MapperC : MapperS).wrapExtendsIfNotFinal(alias.expression)»
+							«val returnType = (multi ? MAPPER_C as JavaGenericTypeDeclaration<?> : MAPPER_S).wrapExtendsIfNotFinal(alias.expression)»
 							
 							@Override
 							protected «returnType» «classScope.getIdentifierOrThrow(alias)»(«inputs.inputsAsParameters(aliasScope)») «expressionGenerator.javaCode(alias.expression, returnType, aliasScope).completeAsReturn.toBlock»
@@ -413,12 +413,12 @@ class FunctionGenerator {
 				if (needsToCopy) {
 					javaExpr =
 						javaExpr
-							.mapExpressionIfNotNull[JavaExpression.from('''new «ArrayList»<>(«it»)''', List.wrap(effectiveExprType.itemType))]
+							.mapExpressionIfNotNull[JavaExpression.from('''new «ArrayList»<>(«it»)''', LIST.wrap(effectiveExprType.itemType))]
 				}
 			}
 			switch(op.ROperationType) {
 				case ADD: {
-					javaExpr = coercionService.addCoercions(javaExpr, attribute.isMulti ? List.wrapExtends(attribute.toBuilderItemType) : attribute.toBuilderItemType, scope)
+					javaExpr = coercionService.addCoercions(javaExpr, attribute.isMulti ? LIST.wrapExtends(attribute.toBuilderItemType) : attribute.toBuilderItemType, scope)
 					javaExpr
 						.mapExpression[
 							JavaExpression.from(
@@ -463,7 +463,7 @@ class FunctionGenerator {
 			if (cardinality.isMulti(op.expression)) {
 				val lambdaScope = scope.lambdaScope
 				val item = lambdaScope.createUniqueIdentifier("item")
-				expressionGenerator.javaCode(op.expression, MapperC.wrap(op.expression), scope)
+				expressionGenerator.javaCode(op.expression, MAPPER_C.wrap(op.expression), scope)
 					.collapseToSingleExpression(scope)
 					.mapExpression[
 						JavaExpression.from(
@@ -476,7 +476,7 @@ class FunctionGenerator {
 										.build())
 									.collect(«Collectors».toList())
 							''',
-							List.wrap(metaClass)
+							LIST.wrap(metaClass)
 						)
 					]
 			} else {
@@ -621,7 +621,7 @@ class FunctionGenerator {
 	private def JavaType toBuilderType(RAttribute rAttribute) {
 		val javaType = rAttribute.toBuilderItemType
 		if (rAttribute.multi) {
-			return List.wrap(javaType)
+			return LIST.wrap(javaType)
 		} else {
 			return javaType
 		}
diff --git a/rosetta-lang/src/main/java/com/regnosys/rosetta/generator/java/object/MetaFieldGenerator.xtend b/rosetta-lang/src/main/java/com/regnosys/rosetta/generator/java/object/MetaFieldGenerator.xtend
index 6c4ed5cfc..89faa86ec 100644
--- a/rosetta-lang/src/main/java/com/regnosys/rosetta/generator/java/object/MetaFieldGenerator.xtend
+++ b/rosetta-lang/src/main/java/com/regnosys/rosetta/generator/java/object/MetaFieldGenerator.xtend
@@ -40,6 +40,7 @@ import com.rosetta.util.types.JavaClass
 import com.rosetta.util.types.JavaParameterizedType
 import javax.inject.Inject
 import com.rosetta.util.types.generated.GeneratedJavaClass
+import com.fasterxml.jackson.core.type.TypeReference
 
 class MetaFieldGenerator {
 	@Inject extension ImportManagerExtension
@@ -231,7 +232,7 @@ class MetaFieldGenerator {
 			valueAttribute, metaAttribute
 		])
 		
-		val FWMType = JavaParameterizedType.from(FieldWithMeta, typeCall.typeCallToRType.toJavaReferenceType)
+		val FWMType = JavaParameterizedType.from(new TypeReference<FieldWithMeta<?>>() {}, typeCall.typeCallToRType.toJavaReferenceType)
 		
 		val scope = new JavaScope(metaJavaType.packageName)
 		
@@ -280,7 +281,7 @@ class MetaFieldGenerator {
 		d.model = RosettaFactory.eINSTANCE.createRosettaModel
 		d.model.name = metaJavaType.packageName.withDots
 		d.attributes.addAll(referenceAttributes(typeCall))
-		val refInterface = JavaParameterizedType.from(ReferenceWithMeta, typeCall.typeCallToRType.toJavaReferenceType)
+		val refInterface = JavaParameterizedType.from(new TypeReference<ReferenceWithMeta<?>>() {}, typeCall.typeCallToRType.toJavaReferenceType)
 		
 		val scope = new JavaScope(root.metaField)
 		
diff --git a/rosetta-lang/src/main/java/com/regnosys/rosetta/generator/java/reports/ReportGenerator.xtend b/rosetta-lang/src/main/java/com/regnosys/rosetta/generator/java/reports/ReportGenerator.xtend
index d1ee97a68..03a8a1e4a 100644
--- a/rosetta-lang/src/main/java/com/regnosys/rosetta/generator/java/reports/ReportGenerator.xtend
+++ b/rosetta-lang/src/main/java/com/regnosys/rosetta/generator/java/reports/ReportGenerator.xtend
@@ -11,6 +11,7 @@ import com.rosetta.util.types.JavaParameterizedType
 import javax.inject.Inject
 import org.eclipse.xtext.generator.IFileSystemAccess2
 import com.regnosys.rosetta.rosetta.RosettaReport
+import com.fasterxml.jackson.core.type.TypeReference
 
 class ReportGenerator {
 	@Inject extension RObjectFactory
@@ -23,7 +24,7 @@ class ReportGenerator {
 		val rFunction = buildRFunction(report)
 		val clazz = rFunction.toFunctionJavaClass
 		val topScope = new JavaScope(clazz.packageName)
-		val baseInterface = JavaParameterizedType.from(ReportFunction, rFunction.inputs.head.attributeToJavaType, rFunction.output.attributeToJavaType)
+		val baseInterface = JavaParameterizedType.from(new TypeReference<ReportFunction<?, ?>>() {}, rFunction.inputs.head.attributeToJavaType, rFunction.output.attributeToJavaType)
 		val reportAnnotationArguments = '''namespace="«report.model.name»", body="«report.regulatoryBody.body.name»", corpusList={«FOR corpus: report.regulatoryBody.corpusList SEPARATOR ", "»"«corpus.name»"«ENDFOR»}'''
 		val classBody = functionGenerator.rBuildClass(rFunction, false, #[baseInterface], #{com.rosetta.model.lib.annotations.RosettaReport -> reportAnnotationArguments}, true, topScope);
 		val content = buildClass(clazz.packageName, classBody, topScope)
diff --git a/rosetta-lang/src/main/java/com/regnosys/rosetta/generator/java/reports/RuleGenerator.xtend b/rosetta-lang/src/main/java/com/regnosys/rosetta/generator/java/reports/RuleGenerator.xtend
index 656397b5d..4a4d84f4d 100644
--- a/rosetta-lang/src/main/java/com/regnosys/rosetta/generator/java/reports/RuleGenerator.xtend
+++ b/rosetta-lang/src/main/java/com/regnosys/rosetta/generator/java/reports/RuleGenerator.xtend
@@ -11,6 +11,7 @@ import com.rosetta.model.lib.reports.ReportFunction
 import com.rosetta.util.types.JavaParameterizedType
 import com.regnosys.rosetta.generator.java.function.FunctionGenerator
 import com.regnosys.rosetta.rosetta.RosettaRule
+import com.fasterxml.jackson.core.type.TypeReference
 
 class RuleGenerator {
 	@Inject extension JavaTypeTranslator
@@ -22,7 +23,7 @@ class RuleGenerator {
 	def generate(RootPackage root, IFileSystemAccess2 fsa, RosettaRule rule, String version) {
 		val rFunctionRule = buildRFunction(rule)
 		val clazz = rFunctionRule.toFunctionJavaClass
-		val baseInterface = JavaParameterizedType.from(ReportFunction, rFunctionRule.inputs.head.attributeToJavaType, rFunctionRule.output.attributeToJavaType)
+		val baseInterface = JavaParameterizedType.from(new TypeReference<ReportFunction<?, ?>>() {}, rFunctionRule.inputs.head.attributeToJavaType, rFunctionRule.output.attributeToJavaType)
 		val topScope = new JavaScope(clazz.packageName)
 		val classBody = functionGenerator.rBuildClass(rFunctionRule, false, #[baseInterface], emptyMap, true, topScope)
 		
diff --git a/rosetta-lang/src/main/java/com/regnosys/rosetta/generator/java/reports/TabulatorGenerator.xtend b/rosetta-lang/src/main/java/com/regnosys/rosetta/generator/java/reports/TabulatorGenerator.xtend
index a012d5f30..bf08ee357 100644
--- a/rosetta-lang/src/main/java/com/regnosys/rosetta/generator/java/reports/TabulatorGenerator.xtend
+++ b/rosetta-lang/src/main/java/com/regnosys/rosetta/generator/java/reports/TabulatorGenerator.xtend
@@ -92,7 +92,7 @@ class TabulatorGenerator {
 		}
 	}
 	
-	private def StringConcatenationClient reportTabulatorClassBody(RosettaReport report, Map<Attribute, RosettaRule> context, JavaScope topScope, JavaClass<Tabulator> tabulatorClass) {
+	private def StringConcatenationClient reportTabulatorClassBody(RosettaReport report, Map<Attribute, RosettaRule> context, JavaScope topScope, JavaClass<Tabulator<?>> tabulatorClass) {
 		val reportType = report.reportType
 		val reportClass = new RDataType(reportType).toJavaReferenceType
 		
@@ -131,7 +131,7 @@ class TabulatorGenerator {
 			// There is no available tabulator for `reportType`,
 			// so we generate a dummy implementation.
 			'''
-			public class «tabulatorClass» implements «Tabulator»<«reportClass»> {				
+			public class «tabulatorClass» implements «Tabulator»<«reportClass»> {
 				@Override
 				public «List»<«Field»> getFields() {
 					return «Arrays».asList();
@@ -146,7 +146,7 @@ class TabulatorGenerator {
 		}
 	}
 	
-	private def StringConcatenationClient tabulatorClassBody(Data reportType, Optional<RosettaExternalRuleSource> ruleSource, Map<Attribute, RosettaRule> context, JavaScope topScope, JavaClass<Tabulator> tabulatorClass) {
+	private def StringConcatenationClient tabulatorClassBody(Data reportType, Optional<RosettaExternalRuleSource> ruleSource, Map<Attribute, RosettaRule> context, JavaScope topScope, JavaClass<Tabulator<?>> tabulatorClass) {
 		val reportClass = new RDataType(reportType).toJavaReferenceType
 		
 		val classScope = topScope.classScope(reportClass.simpleName)
@@ -257,9 +257,9 @@ class TabulatorGenerator {
 		
 		if (rType instanceof RDataType) {
 			val resultType = if (attr.card.isMany) {
-				List.wrap(List.wrap(JavaClass.from(FieldValue)))
+				LIST.wrap(LIST.wrap(JavaClass.from(FieldValue)))
 			} else {
-				List.wrap(JavaClass.from(FieldValue))
+				LIST.wrap(JavaClass.from(FieldValue))
 			}
 			rType.toPolymorphicListOrSingleJavaType(attr.card.isMany)
 			val attrType = rType.data
diff --git a/rosetta-lang/src/main/java/com/regnosys/rosetta/generator/java/types/JavaTypeTranslator.java b/rosetta-lang/src/main/java/com/regnosys/rosetta/generator/java/types/JavaTypeTranslator.java
index 83b653284..93a2f5cc4 100644
--- a/rosetta-lang/src/main/java/com/regnosys/rosetta/generator/java/types/JavaTypeTranslator.java
+++ b/rosetta-lang/src/main/java/com/regnosys/rosetta/generator/java/types/JavaTypeTranslator.java
@@ -90,13 +90,9 @@ private DottedPath getModelPackage(RosettaNamed object) {
 			throw new IllegalArgumentException("Can not compute package name for " + object.eClass().getName() + " " + object.getName() + ". Element is not attached to a RosettaModel.");
 		return modelPackage(model);
 	}
-	private JavaClass<?> rosettaNamedToJavaClass(RosettaNamed object) {
-		ModelSymbolId id = getSymbolId(object);
-		return new GeneratedJavaClass<>(id.getNamespace(), id.getName(), Object.class);
-	}
 	
-	public JavaParameterizedType<List> toPolymorphicList(JavaReferenceType t) {
-		return typeUtil.wrapExtends(List.class, t);
+	public JavaParameterizedType<List<?>> toPolymorphicList(JavaReferenceType t) {
+		return typeUtil.wrapExtends(typeUtil.LIST, t);
 	}
 	public JavaClass<? extends RosettaFunction> toFunctionJavaClass(RFunction func) {
 		switch (func.getOrigin()) {
@@ -116,24 +112,24 @@ public JavaClass<RosettaFunction> toFunctionJavaClass(Function func) {
 	public JavaClass<RosettaFunction> toFunctionJavaClass(RosettaExternalFunction func) {
 		return new GeneratedJavaClass<>(packages.defaultLibFunctions(), func.getName(), RosettaFunction.class);
 	}
-	public JavaClass<ReportFunction> toReportFunctionJavaClass(RosettaReport report) {
+	public JavaClass<ReportFunction<?, ?>> toReportFunctionJavaClass(RosettaReport report) {
 		return generatedJavaClassService.toJavaReportFunction(getReportId(report));
 	}
-	public JavaClass<Tabulator> toReportTabulatorJavaClass(RosettaReport report) {
+	public JavaClass<Tabulator<?>> toReportTabulatorJavaClass(RosettaReport report) {
 		return generatedJavaClassService.toJavaReportTabulator(getReportId(report));
 	}
-	public JavaClass<Tabulator> toTabulatorJavaClass(Data type, Optional<RosettaExternalRuleSource> ruleSource) {
+	public JavaClass<Tabulator<?>> toTabulatorJavaClass(Data type, Optional<RosettaExternalRuleSource> ruleSource) {
 		ModelSymbolId typeId = getSymbolId(type);
 		Optional<RosettaExternalRuleSource> containingRuleSource = ruleSource.flatMap((rs) -> findContainingSuperRuleSource(type, rs));
 		if (containingRuleSource.isEmpty()) {
 			DottedPath packageName = typeId.getNamespace().child("reports");
-			String simpleName = typeId.getName() + "Tabulator";
-			return new GeneratedJavaClass<>(packageName, simpleName, Tabulator.class);
+			String simpleName = typeId.getName() + "TypeTabulator";
+			return new GeneratedJavaClass<>(packageName, simpleName, new com.fasterxml.jackson.core.type.TypeReference<Tabulator<?>>() {});
 		}
 		ModelSymbolId sourceId = getSymbolId(containingRuleSource.get());
 		DottedPath packageName = sourceId.getNamespace().child("reports");
-		String simpleName = typeId.getName() + sourceId.getName() + "Tabulator";
-		return new GeneratedJavaClass<>(packageName, simpleName, Tabulator.class);
+		String simpleName = typeId.getName() + sourceId.getName() + "TypeTabulator";
+		return new GeneratedJavaClass<>(packageName, simpleName, new com.fasterxml.jackson.core.type.TypeReference<Tabulator<?>>() {});
 	}
 	private Optional<RosettaExternalRuleSource> findContainingSuperRuleSource(Data type, RosettaExternalRuleSource ruleSource) {
 		if (ruleSource.getExternalClasses().stream().filter(c -> c.getData().equals(type)).findAny().isPresent()) {
@@ -165,7 +161,7 @@ public JavaReferenceType toMultiMetaOrRegularJavaType(ExpandedAttribute expAttr)
 			if (expAttr.isDataType() || expAttr.hasMetas()) {
 				return toPolymorphicList(singleType);
 			} else {
-				return typeUtil.wrap(List.class, singleType);
+				return typeUtil.wrap(typeUtil.LIST, singleType);
 			}
 		}
 		return singleType;
@@ -255,7 +251,7 @@ public JavaReferenceType toJavaReferenceType(Optional<RType> type) {
 	public JavaReferenceType attributeToJavaType(RAttribute rAttribute) {
 		JavaReferenceType itemType = toJavaReferenceType(rAttribute.getRType());
 		if (rAttribute.isMulti()) {
-			return typeUtil.wrapExtendsIfNotFinal(List.class, itemType);
+			return typeUtil.wrapExtendsIfNotFinal(typeUtil.LIST, itemType);
 		} else {
 			return itemType;
 		}
@@ -278,7 +274,7 @@ public JavaReferenceType toPolymorphicListOrSingleJavaType(RType type, boolean i
 	}
 	public JavaReferenceType toListOrSingleJavaType(RType type, boolean isMany) {
 		if (isMany) {
-			return typeUtil.wrap(List.class, toJavaReferenceType(type));
+			return typeUtil.wrap(typeUtil.LIST, toJavaReferenceType(type));
 		} else
 			return toJavaReferenceType(type);
 	}
diff --git a/rosetta-lang/src/main/java/com/regnosys/rosetta/generator/java/types/JavaTypeUtil.java b/rosetta-lang/src/main/java/com/regnosys/rosetta/generator/java/types/JavaTypeUtil.java
index c941ef325..c1b46b3ba 100644
--- a/rosetta-lang/src/main/java/com/regnosys/rosetta/generator/java/types/JavaTypeUtil.java
+++ b/rosetta-lang/src/main/java/com/regnosys/rosetta/generator/java/types/JavaTypeUtil.java
@@ -10,6 +10,7 @@
 
 import javax.inject.Inject;
 
+import com.fasterxml.jackson.core.type.TypeReference;
 import com.regnosys.rosetta.rosetta.expression.RosettaExpression;
 import com.regnosys.rosetta.types.RosettaTypeProvider;
 import com.rosetta.model.lib.expression.ComparisonResult;
@@ -50,39 +51,34 @@ public class JavaTypeUtil {
 	public final JavaClass<Cloneable> CLONEABLE = JavaClass.CLONEABLE;
 	public final JavaClass<Serializable> SERIALIZABLE = JavaClass.SERIALIZABLE;
 	
-	@SuppressWarnings("rawtypes")
-	public final JavaClass<List> LIST = JavaClass.from(List.class);
-	@SuppressWarnings("rawtypes")
-	public final JavaClass<Mapper> MAPPER = JavaClass.from(Mapper.class);
-	@SuppressWarnings("rawtypes")
-	public final JavaClass<MapperS> MAPPER_S = JavaClass.from(MapperS.class);
-	@SuppressWarnings("rawtypes")
-	public final JavaClass<MapperC> MAPPER_C = JavaClass.from(MapperC.class);
+	public final JavaGenericTypeDeclaration<List<?>> LIST = JavaGenericTypeDeclaration.from(new TypeReference<>() {});
+	public final JavaGenericTypeDeclaration<Mapper<?>> MAPPER = JavaGenericTypeDeclaration.from(new TypeReference<>() {});
+	public final JavaGenericTypeDeclaration<MapperS<?>> MAPPER_S = JavaGenericTypeDeclaration.from(new TypeReference<>() {});
+	public final JavaGenericTypeDeclaration<MapperC<?>> MAPPER_C = JavaGenericTypeDeclaration.from(new TypeReference<>() {});
 	public final JavaClass<ComparisonResult> COMPARISON_RESULT = JavaClass.from(ComparisonResult.class);
-	@SuppressWarnings("rawtypes")
-	public final JavaClass<MapperListOfLists> MAPPER_LIST_OF_LISTS = JavaClass.from(MapperListOfLists.class);
+	public final JavaGenericTypeDeclaration<MapperListOfLists<?>> MAPPER_LIST_OF_LISTS = JavaGenericTypeDeclaration.from(new TypeReference<>() {});
 
-	public <T> JavaParameterizedType<T> wrap(Class<T> wrapperType, JavaType itemType) {
+	public <T> JavaParameterizedType<T> wrap(JavaGenericTypeDeclaration<T> wrapperType, JavaType itemType) {
 		return JavaParameterizedType.from(wrapperType, itemType.toReferenceType());
 	}
-	public <T> JavaParameterizedType<T> wrap(Class<T> wrapperType, Class<?> itemType) {
+	public <T> JavaParameterizedType<T> wrap(JavaGenericTypeDeclaration<T> wrapperType, Class<?> itemType) {
 		return wrap(wrapperType, JavaType.from(itemType));
 	}
-	public <T> JavaParameterizedType<T> wrap(Class<T> wrapperType, RosettaExpression item) {
+	public <T> JavaParameterizedType<T> wrap(JavaGenericTypeDeclaration<T> wrapperType, RosettaExpression item) {
 		return wrap(wrapperType, typeTranslator.toJavaReferenceType(typeProvider.getRType(item)));
 	}
 	
-	public <T> JavaParameterizedType<T> wrapExtends(Class<T> wrapperType, JavaType itemType) {
+	public <T> JavaParameterizedType<T> wrapExtends(JavaGenericTypeDeclaration<T> wrapperType, JavaType itemType) {
 		return JavaParameterizedType.from(wrapperType, JavaWildcardTypeArgument.extendsBound(itemType.toReferenceType()));
 	}
-	public <T> JavaParameterizedType<T> wrapExtends(Class<T> wrapperType, Class<?> itemType) {
+	public <T> JavaParameterizedType<T> wrapExtends(JavaGenericTypeDeclaration<T> wrapperType, Class<?> itemType) {
 		return wrapExtends(wrapperType, JavaType.from(itemType));
 	}
-	public <T> JavaParameterizedType<T> wrapExtends(Class<T> wrapperType, RosettaExpression item) {
+	public <T> JavaParameterizedType<T> wrapExtends(JavaGenericTypeDeclaration<T> wrapperType, RosettaExpression item) {
 		return wrapExtends(wrapperType, typeTranslator.toJavaReferenceType(typeProvider.getRType(item)));
 	}
 	
-	public <T> JavaParameterizedType<T> wrapExtendsIfNotFinal(Class<T> wrapperType, JavaType itemType) {
+	public <T> JavaParameterizedType<T> wrapExtendsIfNotFinal(JavaGenericTypeDeclaration<T> wrapperType, JavaType itemType) {
 		if (itemType instanceof RJavaPojoInterface) {
 			return wrapExtends(wrapperType, itemType);
 		} else {
@@ -95,10 +91,10 @@ public <T> JavaParameterizedType<T> wrapExtendsIfNotFinal(Class<T> wrapperType,
 //			return wrapExtends(wrapperType, itemType);
 //		}
 	}
-	public <T> JavaParameterizedType<T> wrapExtendsIfNotFinal(Class<T> wrapperType, Class<?> itemType) {
+	public <T> JavaParameterizedType<T> wrapExtendsIfNotFinal(JavaGenericTypeDeclaration<T> wrapperType, Class<?> itemType) {
 		return wrapExtendsIfNotFinal(wrapperType, JavaType.from(itemType));
 	}
-	public <T> JavaParameterizedType<T> wrapExtendsIfNotFinal(Class<T> wrapperType, RosettaExpression item) {
+	public <T> JavaParameterizedType<T> wrapExtendsIfNotFinal(JavaGenericTypeDeclaration<T> wrapperType, RosettaExpression item) {
 		return wrapExtendsIfNotFinal(wrapperType, typeTranslator.toJavaReferenceType(typeProvider.getRType(item)));
 	}
 	
@@ -156,40 +152,45 @@ public boolean isVoid(JavaType t) {
 	
 	public boolean isList(JavaType t) {
 		if (t instanceof JavaParameterizedType) {
-			return LIST.equals(((JavaParameterizedType<?>) t).getGenericTypeDeclaration().getBaseType());
+			return LIST.equals(((JavaParameterizedType<?>) t).getGenericTypeDeclaration());
 		}
 		return LIST.equals(t);
 	}
 	
 	public boolean extendsMapper(JavaType t) {
-		return t.isSubtypeOf(MAPPER);
+		if (t instanceof JavaParameterizedType) {
+			return ((JavaParameterizedType<?>) t).getGenericTypeDeclaration().extendsDeclaration(MAPPER);
+		} else if (t instanceof JavaClass) {
+			return ((JavaClass<?>) t).extendsDeclaration(MAPPER);
+		}
+		return false;
 	}
 	public boolean isMapper(JavaType t) {
 		if (t instanceof JavaParameterizedType) {
-			return MAPPER.equals(((JavaParameterizedType<?>) t).getGenericTypeDeclaration().getBaseType());
+			return MAPPER.equals(((JavaParameterizedType<?>) t).getGenericTypeDeclaration());
 		}
-		return MAPPER.equals(t);
+		return false;
 	}
 	public boolean isMapperS(JavaType t) {
 		if (t instanceof JavaParameterizedType) {
-			return MAPPER_S.equals(((JavaParameterizedType<?>) t).getGenericTypeDeclaration().getBaseType());
+			return MAPPER_S.equals(((JavaParameterizedType<?>) t).getGenericTypeDeclaration());
 		}
-		return MAPPER_S.equals(t);
+		return false;
 	}
 	public boolean isMapperC(JavaType t) {
 		if (t instanceof JavaParameterizedType) {
-			return MAPPER_C.equals(((JavaParameterizedType<?>) t).getGenericTypeDeclaration().getBaseType());
+			return MAPPER_C.equals(((JavaParameterizedType<?>) t).getGenericTypeDeclaration());
 		}
-		return MAPPER_C.equals(t);
+		return false;
 	}
 	public boolean isComparisonResult(JavaType t) {
 		return COMPARISON_RESULT.equals(t);
 	}
 	public boolean isMapperListOfLists(JavaType t) {
 		if (t instanceof JavaParameterizedType) {
-			return MAPPER_LIST_OF_LISTS.equals(((JavaParameterizedType<?>) t).getGenericTypeDeclaration().getBaseType());
+			return MAPPER_LIST_OF_LISTS.equals(((JavaParameterizedType<?>) t).getGenericTypeDeclaration());
 		}
-		return MAPPER_LIST_OF_LISTS.equals(t);
+		return false;
 	}
 	
 	public boolean isWrapper(JavaType t) {
diff --git a/rosetta-runtime/src/main/java/com/rosetta/util/types/JavaGenericTypeDeclaration.java b/rosetta-runtime/src/main/java/com/rosetta/util/types/JavaGenericTypeDeclaration.java
index 59e36b0e3..770865381 100644
--- a/rosetta-runtime/src/main/java/com/rosetta/util/types/JavaGenericTypeDeclaration.java
+++ b/rosetta-runtime/src/main/java/com/rosetta/util/types/JavaGenericTypeDeclaration.java
@@ -11,6 +11,7 @@
 import java.util.Objects;
 import java.util.stream.Collectors;
 
+import com.fasterxml.jackson.core.type.TypeReference;
 import com.rosetta.util.types.JavaClass.JavaClassImpl;
 
 public abstract class JavaGenericTypeDeclaration<T> implements JavaTypeDeclaration<T> {
@@ -121,6 +122,9 @@ public boolean isFinal() {
 	public static <T> JavaGenericTypeDeclaration<T> from(Class<T> c) {
 		return new JavaGenericTypeDeclarationImpl<>(c);
 	}
+	public static <T> JavaGenericTypeDeclaration<T> from(TypeReference<T> typeRef) {
+		return from(JavaParameterizedType.extractRawClass(typeRef.getType()));
+	}
 
 	public abstract JavaClass<T> getBaseType();
 	public abstract List<JavaTypeVariable> getParameters();
diff --git a/rosetta-runtime/src/main/java/com/rosetta/util/types/JavaParameterizedType.java b/rosetta-runtime/src/main/java/com/rosetta/util/types/JavaParameterizedType.java
index 03adc3795..9083d8943 100644
--- a/rosetta-runtime/src/main/java/com/rosetta/util/types/JavaParameterizedType.java
+++ b/rosetta-runtime/src/main/java/com/rosetta/util/types/JavaParameterizedType.java
@@ -1,6 +1,8 @@
 package com.rosetta.util.types;
 
+import java.lang.reflect.GenericArrayType;
 import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
 import java.lang.reflect.TypeVariable;
 import java.util.Arrays;
 import java.util.HashMap;
@@ -10,21 +12,25 @@
 import java.util.Optional;
 import java.util.stream.Collectors;
 
+import org.apache.commons.lang3.Validate;
+
+import com.fasterxml.jackson.core.type.TypeReference;
 import com.rosetta.util.DottedPath;
 
 
 public abstract class JavaParameterizedType<T> extends JavaClass<T> {
 	protected static class JavaParameterizedTypeImpl<T> extends JavaParameterizedType<T> {
-		private final JavaGenericTypeDeclaration<T> genericTypeDeclaration;
+		private final JavaGenericTypeDeclaration<? super T> genericTypeDeclaration;
 		private final List<JavaTypeArgument> arguments;
 
-		public JavaParameterizedTypeImpl(JavaGenericTypeDeclaration<T> genericTypeDeclaration, List<JavaTypeArgument> arguments) {
+		public JavaParameterizedTypeImpl(JavaGenericTypeDeclaration<? super T> genericTypeDeclaration, List<JavaTypeArgument> arguments) {
+			Validate.isTrue(genericTypeDeclaration.getParameters().size() == arguments.size());
 			this.genericTypeDeclaration = genericTypeDeclaration;
 			this.arguments = arguments;
 		}
 
 		@Override
-		public JavaGenericTypeDeclaration<T> getGenericTypeDeclaration() {
+		public JavaGenericTypeDeclaration<? super T> getGenericTypeDeclaration() {
 			return genericTypeDeclaration;
 		}
 
@@ -34,27 +40,43 @@ public List<JavaTypeArgument> getArguments() {
 		}
 	}
 	
-	public static <T> JavaParameterizedType<T> from(Class<T> rawType, List<JavaTypeArgument> arguments) {
-		return from(JavaGenericTypeDeclaration.from(rawType), arguments);
+	public static <T> JavaParameterizedType<T> from(TypeReference<T> typeRef, List<JavaTypeArgument> arguments) {
+		Type t = typeRef.getType();
+		if (t instanceof ParameterizedType) {
+			return from(JavaGenericTypeDeclaration.from(extractRawClass(t)), arguments);
+		}
+		throw new IllegalArgumentException("Type " + t + " is not a parameterized type.");
 	}
-	public static <T> JavaParameterizedType<T> from(Class<T> rawType, JavaTypeArgument... arguments) {
-		return from(rawType, Arrays.asList(arguments));
+	public static <T> JavaParameterizedType<T> from(TypeReference<T> typeRef, JavaTypeArgument... arguments) {
+		return from(typeRef, Arrays.asList(arguments));
 	}
 	public static <T> JavaParameterizedType<T> from(Class<T> rawType, ParameterizedType t, Map<TypeVariable<?>, JavaTypeVariable> context) {
 		return from(
-				rawType, 
+				JavaGenericTypeDeclaration.from(rawType), 
 				Arrays.stream(t.getActualTypeArguments())
 					.map(ta -> JavaTypeArgument.from(ta, context))
 					.collect(Collectors.toList()));
 	}
-	public static <T> JavaParameterizedType<T> from(JavaGenericTypeDeclaration<T> typeDeclaration, JavaTypeArgument... arguments) {
+	public static <T> JavaParameterizedType<T> from(JavaGenericTypeDeclaration<? super T> typeDeclaration, JavaTypeArgument... arguments) {
 		return from(typeDeclaration, Arrays.asList(arguments));
 	}
-	public static <T> JavaParameterizedType<T> from(JavaGenericTypeDeclaration<T> typeDeclaration, List<JavaTypeArgument> arguments) {
+	public static <T> JavaParameterizedType<T> from(JavaGenericTypeDeclaration<? super T> typeDeclaration, List<JavaTypeArgument> arguments) {
 		return new JavaParameterizedTypeImpl<>(typeDeclaration, arguments);
 	}
+	@SuppressWarnings("unchecked")
+	public static <U> Class<U> extractRawClass(Type t) {
+		if (t instanceof Class<?>) {
+			return (Class<U>) t;
+		} else if (t instanceof GenericArrayType) {
+			return extractRawClass(((GenericArrayType) t).getGenericComponentType());
+		} else if (t instanceof ParameterizedType) {
+			return extractRawClass(((ParameterizedType) t).getRawType());
+		} else {
+			throw new IllegalArgumentException("Cannot use a type reference to " + t + ". No raw class found.");
+		}
+	}
 	
-	public abstract JavaGenericTypeDeclaration<T> getGenericTypeDeclaration();
+	public abstract JavaGenericTypeDeclaration<? super T> getGenericTypeDeclaration();
 	public abstract List<JavaTypeArgument> getArguments();
 	
 	@Override
@@ -163,9 +185,10 @@ public JavaParameterizedType<T> applySubstitution(Map<JavaTypeVariable, JavaType
 		return new JavaParameterizedTypeImpl<>(getGenericTypeDeclaration(), newArguments);
 	}
 	
+	@SuppressWarnings("unchecked")
 	@Override
 	public Class<? extends T> loadClass(ClassLoader classLoader) throws ClassNotFoundException {
-		return getGenericTypeDeclaration().loadClass(classLoader);
+		return (Class<? extends T>) getGenericTypeDeclaration().loadClass(classLoader);
 	}
 	
 	@Override
diff --git a/rosetta-runtime/src/main/java/com/rosetta/util/types/generated/GeneratedJavaClass.java b/rosetta-runtime/src/main/java/com/rosetta/util/types/generated/GeneratedJavaClass.java
index 79bb2b615..686e6a340 100644
--- a/rosetta-runtime/src/main/java/com/rosetta/util/types/generated/GeneratedJavaClass.java
+++ b/rosetta-runtime/src/main/java/com/rosetta/util/types/generated/GeneratedJavaClass.java
@@ -1,27 +1,39 @@
 package com.rosetta.util.types.generated;
 
+import java.lang.reflect.Type;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 import java.util.Objects;
 
+import com.fasterxml.jackson.core.type.TypeReference;
 import com.rosetta.util.DottedPath;
 import com.rosetta.util.types.JavaClass;
+import com.rosetta.util.types.JavaParameterizedType;
 import com.rosetta.util.types.JavaType;
 import com.rosetta.util.types.JavaTypeDeclaration;
 
 public class GeneratedJavaClass<T> extends JavaClass<T> {
 	private final DottedPath packageName;
 	private final String simpleName;
-	private final Class<T> superType;
+	private final Type supertype;
+	private final Class<? super T> rawSupertype;
 	
-	public GeneratedJavaClass(DottedPath packageName, String simpleName, Class<T> superType) {
+	private GeneratedJavaClass(DottedPath packageName, String simpleName, Type supertype, Class<? super T> rawSupertype) {
 		Objects.requireNonNull(packageName);
 		Objects.requireNonNull(simpleName);
-		Objects.requireNonNull(superType);
+		Objects.requireNonNull(supertype);
+		Objects.requireNonNull(rawSupertype);
 		this.packageName = packageName;
 		this.simpleName = simpleName;
-		this.superType = superType;
+		this.supertype = supertype;
+		this.rawSupertype = rawSupertype;
+	}
+	public GeneratedJavaClass(DottedPath packageName, String simpleName, Class<T> supertype) {
+		this(packageName, simpleName, supertype, supertype);
+	}
+	public GeneratedJavaClass(DottedPath packageName, String simpleName, TypeReference<T> supertypeRef) {
+		this(packageName, simpleName, supertypeRef.getType(), JavaParameterizedType.extractRawClass(supertypeRef.getType()));
 	}
 	
 	@Override
@@ -39,35 +51,43 @@ public DottedPath getPackageName() {
 		return packageName;
 	}
 
+	@SuppressWarnings("unchecked")
 	@Override
 	public Class<? extends T> loadClass(ClassLoader classLoader) throws ClassNotFoundException {
-		return Class.forName(getCanonicalName().toString(), true, classLoader).asSubclass(superType);
+		return (Class<? extends T>) Class.forName(getCanonicalName().toString(), true, classLoader).asSubclass(rawSupertype);
 	}
 
 	@Override
-	public JavaClass<? super T> getSuperclassDeclaration() {
-		if (superType.isInterface()) {
+	public JavaTypeDeclaration<? super T> getSuperclassDeclaration() {
+		if (rawSupertype.isInterface()) {
 			return JavaClass.OBJECT;
 		}
-		return JavaClass.from(superType);
+		return JavaTypeDeclaration.from(rawSupertype);
 	}
 	
+	@SuppressWarnings("unchecked")
 	@Override
 	public JavaClass<? super T> getSuperclass() {
-		return getSuperclassDeclaration();
+		if (rawSupertype.isInterface()) {
+			return JavaClass.OBJECT;
+		}
+		return (JavaClass<? super T>) JavaClass.from(supertype, Collections.emptyMap());
 	}
 	
 	@Override
-	public List<JavaClass<?>> getInterfaceDeclarations() {
-		if (superType.isInterface()) {
-			return Arrays.asList(JavaClass.from(superType));
+	public List<JavaTypeDeclaration<?>> getInterfaceDeclarations() {
+		if (rawSupertype.isInterface()) {
+			return Arrays.asList(JavaTypeDeclaration.from(rawSupertype));
 		}
 		return Collections.emptyList();
 	}
 	
 	@Override
 	public List<JavaClass<?>> getInterfaces() {
-		return getInterfaceDeclarations();
+		if (rawSupertype.isInterface()) {
+			return Arrays.asList(JavaClass.from(supertype, Collections.emptyMap()));
+		}
+		return Collections.emptyList();
 	}
 
 	@Override
diff --git a/rosetta-runtime/src/main/java/com/rosetta/util/types/generated/GeneratedJavaClassService.java b/rosetta-runtime/src/main/java/com/rosetta/util/types/generated/GeneratedJavaClassService.java
index d99cc35b2..a71a833e5 100644
--- a/rosetta-runtime/src/main/java/com/rosetta/util/types/generated/GeneratedJavaClassService.java
+++ b/rosetta-runtime/src/main/java/com/rosetta/util/types/generated/GeneratedJavaClassService.java
@@ -1,5 +1,6 @@
 package com.rosetta.util.types.generated;
 
+import com.fasterxml.jackson.core.type.TypeReference;
 import com.rosetta.model.lib.ModelReportId;
 import com.rosetta.model.lib.ModelSymbolId;
 import com.rosetta.model.lib.RosettaModelObject;
@@ -10,15 +11,15 @@
 import com.rosetta.util.types.JavaClass;
 
 public class GeneratedJavaClassService {
-	public JavaClass<ReportFunction> toJavaReportFunction(ModelReportId id) {
+	public JavaClass<ReportFunction<?, ?>> toJavaReportFunction(ModelReportId id) {
 		DottedPath packageName = id.getNamespace().child("reports");
 		String simpleName = id.joinRegulatoryReference() + "ReportFunction";
-		return new GeneratedJavaClass<>(packageName, simpleName, ReportFunction.class);
+		return new GeneratedJavaClass<>(packageName, simpleName, new TypeReference<ReportFunction<?, ?>>() {});
 	}
-	public JavaClass<Tabulator> toJavaReportTabulator(ModelReportId id) {
+	public JavaClass<Tabulator<?>> toJavaReportTabulator(ModelReportId id) {
 		DottedPath packageName = id.getNamespace().child("reports");
 		String simpleName = id.joinRegulatoryReference() + "ReportTabulator";
-		return new GeneratedJavaClass<>(packageName, simpleName, Tabulator.class);
+		return new GeneratedJavaClass<>(packageName, simpleName, new TypeReference<Tabulator<?>>() {});
 	}
 	
 	public JavaClass<RosettaFunction> toJavaFunction(ModelSymbolId id) {
@@ -27,10 +28,10 @@ public JavaClass<RosettaFunction> toJavaFunction(ModelSymbolId id) {
 		return new GeneratedJavaClass<>(packageName, simpleName, RosettaFunction.class);
 	}
 	
-	public JavaClass<ReportFunction> toJavaRule(ModelSymbolId id) {
+	public JavaClass<ReportFunction<?, ?>> toJavaRule(ModelSymbolId id) {
 		DottedPath packageName = id.getNamespace().child("reports");
 		String simpleName = id.getName() + "Rule";
-		return new GeneratedJavaClass<>(packageName, simpleName, ReportFunction.class);
+		return new GeneratedJavaClass<>(packageName, simpleName, new TypeReference<ReportFunction<?, ?>>() {});
 	}
 	
 	public JavaClass<RosettaModelObject> toJavaType(ModelSymbolId id) {
diff --git a/rosetta-testing/src/test/java/com/regnosys/rosetta/generator/java/expression/TypeCoercionTest.xtend b/rosetta-testing/src/test/java/com/regnosys/rosetta/generator/java/expression/TypeCoercionTest.xtend
index e425608d4..735312933 100644
--- a/rosetta-testing/src/test/java/com/regnosys/rosetta/generator/java/expression/TypeCoercionTest.xtend
+++ b/rosetta-testing/src/test/java/com/regnosys/rosetta/generator/java/expression/TypeCoercionTest.xtend
@@ -15,7 +15,6 @@ import com.regnosys.rosetta.generator.java.util.ImportManagerExtension
 import static org.junit.jupiter.api.Assertions.*
 import java.math.BigInteger
 import com.rosetta.model.lib.mapper.MapperS
-import java.util.List
 import com.rosetta.model.lib.mapper.MapperC
 import com.rosetta.model.lib.expression.ComparisonResult
 import java.util.Arrays
@@ -102,7 +101,7 @@ class TypeCoercionTest {
 		
 		return MapperS.of(42);
 		'''
-		assertCoercion(expected, '''42''', JavaPrimitiveType.INT, MapperS.wrap(Integer))
+		assertCoercion(expected, '''42''', JavaPrimitiveType.INT, MAPPER_S.wrap(Integer))
 		
 		expected = '''
 		import com.rosetta.model.lib.mapper.MapperC;
@@ -116,7 +115,7 @@ class TypeCoercionTest {
 			return bigDecimal == null ? MapperC.<BigInteger>ofNull() : MapperC.of(Collections.singletonList(bigDecimal.toBigIntegerExact()));
 		}
 		'''
-		assertCoercion(expected, '''«BigDecimal».valueOf(42)''', BigDecimal, MapperC.wrap(BigInteger))
+		assertCoercion(expected, '''«BigDecimal».valueOf(42)''', BigDecimal, MAPPER_C.wrap(BigInteger))
 		
 		expected = '''
 		import java.util.Collections;
@@ -124,7 +123,7 @@ class TypeCoercionTest {
 		
 		return Collections.<Long>emptyList();
 		'''
-		assertCoercion(expected, '''null''', Void, List.wrap(Long))
+		assertCoercion(expected, '''null''', Void, LIST.wrap(Long))
 				
 		expected = '''
 		import com.rosetta.model.lib.expression.ComparisonResult;
@@ -146,7 +145,7 @@ class TypeCoercionTest {
 		
 		return MapperS.of("ABC").get();
 		'''
-		assertCoercion(expected, '''«MapperS».of("ABC")''', MapperS.wrap(String), String)
+		assertCoercion(expected, '''«MapperS».of("ABC")''', MAPPER_S.wrap(String), String)
 		
 		expected = '''
 		import com.rosetta.model.lib.mapper.MapperS;
@@ -157,7 +156,7 @@ class TypeCoercionTest {
 			return _long == null ? null : Math.toIntExact(_long);
 		}
 		'''
-		assertCoercion(expected, '''«MapperS».of(42)''', MapperS.wrap(Long), Integer)
+		assertCoercion(expected, '''«MapperS».of(42)''', MAPPER_S.wrap(Long), Integer)
 		
 		expected = '''
 		import com.rosetta.model.lib.mapper.MapperC;
@@ -170,7 +169,7 @@ class TypeCoercionTest {
 			return integer == null ? null : BigInteger.valueOf(integer);
 		}
 		'''
-		assertCoercion(expected, '''«MapperC».of(«Arrays».asList(1, 2, 3))''', MapperC.wrap(Integer), BigInteger)
+		assertCoercion(expected, '''«MapperC».of(«Arrays».asList(1, 2, 3))''', MAPPER_C.wrap(Integer), BigInteger)
 		
 		expected = '''
 		import com.rosetta.model.lib.expression.ComparisonResult;
@@ -183,7 +182,7 @@ class TypeCoercionTest {
 		expected = '''
 		return null;
 		'''
-		assertCoercion(expected, '''«MapperS».ofNull()''', MapperS.wrap(Void), Integer)
+		assertCoercion(expected, '''«MapperS».ofNull()''', MAPPER_S.wrap(Void), Integer)
 	}
 	
 	@Test
@@ -197,7 +196,7 @@ class TypeCoercionTest {
 		
 		return ComparisonResult.of(MapperS.of(true));
 		'''
-		assertCoercion(expected, '''«MapperS».of(true)''', MapperS.wrap(Boolean), ComparisonResult)
+		assertCoercion(expected, '''«MapperS».of(true)''', MAPPER_S.wrap(Boolean), ComparisonResult)
 		
 		expected = '''
 		import com.rosetta.model.lib.mapper.MapperS;
@@ -205,7 +204,7 @@ class TypeCoercionTest {
 		
 		return MapperS.of(42).<Integer>map("Type coercion", _long -> _long == null ? null : Math.toIntExact(_long)).getMulti();
 		'''
-		assertCoercion(expected, '''«MapperS».of(42)''', MapperS.wrap(Long), List.wrap(Integer))
+		assertCoercion(expected, '''«MapperS».of(42)''', MAPPER_S.wrap(Long), LIST.wrap(Integer))
 		
 		expected = '''
 		import com.rosetta.model.lib.mapper.MapperC;
@@ -215,7 +214,7 @@ class TypeCoercionTest {
 		
 		return MapperC.of(Arrays.asList(1, 2, 3)).<BigInteger>map("Type coercion", integer -> BigInteger.valueOf(integer)).getMulti();
 		'''
-		assertCoercion(expected, '''«MapperC».of(«Arrays».asList(1, 2, 3))''', MapperC.wrap(Integer), List.wrap(BigInteger))
+		assertCoercion(expected, '''«MapperC».of(«Arrays».asList(1, 2, 3))''', MAPPER_C.wrap(Integer), LIST.wrap(BigInteger))
 		
 		expected = '''
 		import com.rosetta.model.lib.expression.ComparisonResult;
@@ -223,7 +222,7 @@ class TypeCoercionTest {
 		
 		return ComparisonResult.success().asMapper();
 		'''
-		assertCoercion(expected, '''«ComparisonResult».success()''', ComparisonResult, MapperS.wrap(Boolean))
+		assertCoercion(expected, '''«ComparisonResult».success()''', ComparisonResult, MAPPER_S.wrap(Boolean))
 		
 		expected = '''
 		import java.util.Collections;
@@ -231,6 +230,6 @@ class TypeCoercionTest {
 		
 		return Collections.<String>emptyList();
 		'''
-		assertCoercion(expected, '''«MapperS».ofNull()''', MapperS.wrap(Void), List.wrap(String))
+		assertCoercion(expected, '''«MapperS».ofNull()''', MAPPER_S.wrap(Void), LIST.wrap(String))
 	}
 }
\ No newline at end of file
diff --git a/rosetta-testing/src/test/java/com/regnosys/rosetta/generator/java/reports/TabulatorTest.xtend b/rosetta-testing/src/test/java/com/regnosys/rosetta/generator/java/reports/TabulatorTest.xtend
index 45e1eedab..2d27ea935 100644
--- a/rosetta-testing/src/test/java/com/regnosys/rosetta/generator/java/reports/TabulatorTest.xtend
+++ b/rosetta-testing/src/test/java/com/regnosys/rosetta/generator/java/reports/TabulatorTest.xtend
@@ -94,10 +94,10 @@ class TabulatorTest {
 			
 			@RosettaReport(namespace="com.rosetta.test.model", body="TEST_REG", corpusList={"Corp"})
 			public class TEST_REGCorpReportTabulator implements Tabulator<Report> {
-				private final ReportTabulator tabulator;
+				private final ReportTypeTabulator tabulator;
 				
 				@Inject
-				public TEST_REGCorpReportTabulator(ReportTabulator tabulator) {
+				public TEST_REGCorpReportTabulator(ReportTypeTabulator tabulator) {
 					this.tabulator = tabulator;
 				}
 				
@@ -114,7 +114,7 @@ class TabulatorTest {
 		'''
 		assertEquals(expected, reportTabulatorCode)
 		
-		val tabulatorClass = new GeneratedJavaClass(DottedPath.splitOnDots("com.rosetta.test.model.reports"), "ReportTabulator", Tabulator)
+		val tabulatorClass = new GeneratedJavaClass(DottedPath.splitOnDots("com.rosetta.test.model.reports"), "ReportTypeTabulator", Tabulator)
 		
 		val tabulatorCode = code.get(tabulatorClass.canonicalName.withDots)
 		assertThat(tabulatorCode, CoreMatchers.notNullValue())
@@ -136,16 +136,16 @@ class TabulatorTest {
 			import javax.inject.Inject;
 			
 			
-			public class ReportTabulator implements Tabulator<Report> {
+			public class ReportTypeTabulator implements Tabulator<Report> {
 				private final Field basicField;
 				private final Field subreportField;
 				private final Field subreportWithRuleField;
 				
-				private final SubreportTabulator subreportTabulator;
+				private final SubreportTypeTabulator subreportTypeTabulator;
 				
 				@Inject
-				public ReportTabulator(SubreportTabulator subreportTabulator) {
-					this.subreportTabulator = subreportTabulator;
+				public ReportTypeTabulator(SubreportTypeTabulator subreportTypeTabulator) {
+					this.subreportTypeTabulator = subreportTypeTabulator;
 					this.basicField = new FieldImpl(
 						"basic",
 						false,
@@ -158,14 +158,14 @@ class TabulatorTest {
 						false,
 						Optional.empty(),
 						Optional.empty(),
-						subreportTabulator.getFields()
+						subreportTypeTabulator.getFields()
 					);
 					this.subreportWithRuleField = new FieldImpl(
 						"subreportWithRule",
 						false,
 						Optional.of(new ModelSymbolId(DottedPath.of("com", "rosetta", "test", "model"), "SubreportWithRule")),
 						Optional.of("Subreport from a rule"),
-						subreportTabulator.getFields()
+						subreportTypeTabulator.getFields()
 					);
 				}
 				
@@ -178,9 +178,9 @@ class TabulatorTest {
 				public List<FieldValue> tabulate(Report report) {
 					Optional<String> basic = Optional.ofNullable(report.getBasic());
 					Optional<List<FieldValue>> subreport = Optional.ofNullable(report.getSubreport())
-						.map(x -> subreportTabulator.tabulate(x));
+						.map(x -> subreportTypeTabulator.tabulate(x));
 					Optional<List<FieldValue>> subreportWithRule = Optional.ofNullable(report.getSubreportWithRule())
-						.map(x -> subreportTabulator.tabulate(x));
+						.map(x -> subreportTypeTabulator.tabulate(x));
 					return Arrays.asList(
 						new FieldValueImpl(basicField, basic),
 						new NestedFieldValueImpl(subreportField, subreport),
@@ -266,7 +266,7 @@ class TabulatorTest {
 		'''
 		val code = model.generateCode
 
-		val tabulatorClass = new GeneratedJavaClass(DottedPath.splitOnDots("com.rosetta.test.model.reports"), "ReportTabulator", Tabulator)
+		val tabulatorClass = new GeneratedJavaClass(DottedPath.splitOnDots("com.rosetta.test.model.reports"), "ReportTypeTabulator", Tabulator)
 		
 		val tabulatorCode = code.get(tabulatorClass.canonicalName.withDots)
 		assertThat(tabulatorCode, CoreMatchers.notNullValue())
@@ -289,15 +289,15 @@ class TabulatorTest {
 			import javax.inject.Inject;
 			
 			
-			public class ReportTabulator implements Tabulator<Report> {
+			public class ReportTypeTabulator implements Tabulator<Report> {
 				private final Field basicListField;
 				private final Field subreportListField;
 				
-				private final SubreportTabulator subreportTabulator;
+				private final SubreportTypeTabulator subreportTypeTabulator;
 				
 				@Inject
-				public ReportTabulator(SubreportTabulator subreportTabulator) {
-					this.subreportTabulator = subreportTabulator;
+				public ReportTypeTabulator(SubreportTypeTabulator subreportTypeTabulator) {
+					this.subreportTypeTabulator = subreportTypeTabulator;
 					this.basicListField = new FieldImpl(
 						"basicList",
 						true,
@@ -310,7 +310,7 @@ class TabulatorTest {
 						true,
 						Optional.of(new ModelSymbolId(DottedPath.of("com", "rosetta", "test", "model"), "SubreportList")),
 						Optional.of("Subreport group"),
-						subreportTabulator.getFields()
+						subreportTypeTabulator.getFields()
 					);
 				}
 				
@@ -324,7 +324,7 @@ class TabulatorTest {
 					Optional<List<? extends Integer>> basicList = Optional.ofNullable(report.getBasicList());
 					Optional<List<List<FieldValue>>> subreportList = Optional.ofNullable(report.getSubreportList())
 						.map(x -> x.stream()
-							.map(_x -> subreportTabulator.tabulate(_x))
+							.map(_x -> subreportTypeTabulator.tabulate(_x))
 							.collect(Collectors.toList()));
 					return Arrays.asList(
 						new FieldValueImpl(basicListField, basicList),
@@ -413,7 +413,7 @@ class TabulatorTest {
 		'''
 		val code = model.generateCode
 
-		val tabulatorClass = new GeneratedJavaClass(DottedPath.splitOnDots("com.rosetta.test.model.reports"), "ReportTabulator", Tabulator)
+		val tabulatorClass = new GeneratedJavaClass(DottedPath.splitOnDots("com.rosetta.test.model.reports"), "ReportTypeTabulator", Tabulator)
 		
 		val classes = code.compileToClasses
 		val tabulator = classes.<Tabulator<RosettaModelObject>>createInstance(tabulatorClass)
@@ -487,7 +487,7 @@ class TabulatorTest {
 		'''
 		val code = model.generateCode
 		
-		val tabulatorClass = new GeneratedJavaClass(DottedPath.splitOnDots("com.rosetta.test.model.reports"), "ReportTabulator", Tabulator)
+		val tabulatorClass = new GeneratedJavaClass(DottedPath.splitOnDots("com.rosetta.test.model.reports"), "ReportTypeTabulator", Tabulator)
 		
 		val tabulatorCode = code.get(tabulatorClass.canonicalName.withDots)
 		assertThat(tabulatorCode, CoreMatchers.notNullValue())
@@ -508,12 +508,12 @@ class TabulatorTest {
 			import java.util.Optional;
 			
 			
-			public class ReportTabulator implements Tabulator<Report> {
+			public class ReportTypeTabulator implements Tabulator<Report> {
 				private final Field basic1Field;
 				private final Field basic2Field;
 				private final Field basic3Field;
 				
-				public ReportTabulator() {
+				public ReportTypeTabulator() {
 					this.basic1Field = new FieldImpl(
 						"basic1",
 						false,
diff --git a/rosetta-testing/src/test/java/com/regnosys/rosetta/generator/java/reports/TabulatorTestUtil.xtend b/rosetta-testing/src/test/java/com/regnosys/rosetta/generator/java/reports/TabulatorTestUtil.xtend
index cbdfaf627..2fcf7d7d9 100644
--- a/rosetta-testing/src/test/java/com/regnosys/rosetta/generator/java/reports/TabulatorTestUtil.xtend
+++ b/rosetta-testing/src/test/java/com/regnosys/rosetta/generator/java/reports/TabulatorTestUtil.xtend
@@ -17,7 +17,7 @@ import com.rosetta.model.lib.reports.Tabulator.NestedFieldValue
 class TabulatorTestUtil {
 	@Inject Injector injector
 	
-	def <T> T createInstance(Map<String, Class<?>> classes, JavaClass tabulatorClassRepr) {
+	def <T> T createInstance(Map<String, Class<?>> classes, JavaClass<?> tabulatorClassRepr) {
 		val tabulatorClass = classes.get(tabulatorClassRepr.canonicalName.withDots)
 		return injector.getInstance(tabulatorClass) as T
 	}