@@ -10,6 +10,7 @@
     EnumDefinition,
     PropertyDefinition,
     SchemaAllOf,
+    SchemaAnyOf,
     SchemaArray,
     SchemaEnum,
     SchemaItem,
@@ -26,7 +27,9 @@ def build_types(schema: List[SchemaItem]) -> List[TypeDefinition]:
 
 
 def _normalize_typename(typename: str) -> str:
-    return typename[5:-1] if typename.startswith("List[") else typename
+    prefixes = {"List[", "Optional["}
+    prefix = next(filter(lambda p: typename.startswith(p), prefixes), None)
+    return typename[len(prefix) : -1] if prefix else typename
 
 
 def _build_types_for_item(
@@ -89,6 +92,10 @@ def _item_for_nesting(item: SchemaItem) -> SchemaItem:
         first_item = item.all_of[0]
         first_item.name = item.name
         return _item_for_nesting(first_item)
+    if isinstance(item, SchemaAnyOf):
+        first_item = item.any_of[0]
+        first_item.name = item.name
+        return _item_for_nesting(first_item)
     else:
         return item
 
@@ -102,6 +109,8 @@ def _build_property(item: SchemaItem, parent_class_name: str) -> PropertyDefinit
         return _build_property(_item_for_nesting(item), parent_class_name)
     if isinstance(item, SchemaArray):
         return _property_from_array(item, parent_class_name)
+    if isinstance(item, SchemaAnyOf):
+        return _property_from_any_of(item, parent_class_name)
 
     return _property_from_value(item)
 
@@ -142,6 +151,23 @@ def _property_from_array(object: SchemaArray, parent_name: str) -> PropertyDefin
     )
 
 
+def _property_from_any_of(object: SchemaAnyOf, parent_name: str) -> PropertyDefinition:
+    def is_null(item: SchemaItem) -> bool:
+        return isinstance(item, SchemaValue) and item.value_types == ["null"]
+
+    nested_property = _build_property(_item_for_nesting(object), parent_name)
+    is_optional = any(map(is_null, object.any_of))
+
+    if is_optional:
+        return _property(
+            name=object.name,
+            type_name=f"Optional[{nested_property.value_type}]",
+            known_type=nested_property.known_type,
+        )
+    else:
+        return _property(name=object.name, type_name="Any", known_type=True)
+
+
 def _property(name: str, type_name: str, known_type: bool) -> PropertyDefinition:
     return PropertyDefinition(
         name=stringcase.snakecase(name),
 
@@ -4,6 +4,7 @@
     EnumDefinition,
     PropertyDefinition,
     SchemaAllOf,
+    SchemaAnyOf,
     SchemaArray,
     SchemaEnum,
     SchemaObject,
@@ -429,3 +430,98 @@ def test_type_builder_handles_enumerations_with_uppercase_values():
         ],
         depends_on=set(),
     )
+
+
+def test_type_builder_handles_optional_references():
+    """
+    Test type builder handles optional references.
+    """
+    schema = [
+        SchemaObject(
+            name="ObjectA",
+            properties=[
+                SchemaAnyOf(
+                    name="refB",
+                    any_of=[
+                        SchemaReference(name="refB", reference="ObjectB"),
+                        SchemaValue(name="refB", value_type="null"),
+                    ],
+                )
+            ],
+        ),
+        SchemaObject(
+            name="ObjectB",
+            properties=[SchemaValue(name="strField", value_type="string")],
+        ),
+    ]
+
+    build_result = build_types(schema)
+
+    assert len(build_result) == 2
+    assert build_result[0] == ClassDefinition(
+        name="ObjectA",
+        properties=[
+            PropertyDefinition(
+                name="ref_b",
+                key="refB",
+                value_type="Optional[ObjectB]",
+                known_type=False,
+            )
+        ],
+        depends_on={"ObjectB"},
+    )
+    assert build_result[1] == ClassDefinition(
+        name="ObjectB",
+        properties=[
+            PropertyDefinition(
+                name="str_field", key="strField", value_type="str", known_type=True
+            )
+        ],
+        depends_on=set(),
+    )
+
+
+def test_type_builder_resolves_union_types_to_any():
+    """
+    Test type builder resolves union types to Any.
+    """
+    schema = [
+        SchemaObject(
+            name="ObjectA",
+            properties=[
+                SchemaAnyOf(
+                    name="refB",
+                    any_of=[
+                        SchemaReference(name="refB", reference="ObjectB"),
+                        SchemaValue(name="refB", value_type="str"),
+                    ],
+                )
+            ],
+        ),
+        SchemaObject(
+            name="ObjectB",
+            properties=[SchemaValue(name="strField", value_type="string")],
+        ),
+    ]
+
+    build_result = build_types(schema)
+
+    assert len(build_result) == 2
+    assert build_result[0] == ClassDefinition(
+        name="ObjectA",
+        properties=[
+            PropertyDefinition(
+                name="ref_b", key="refB", value_type="Any", known_type=True,
+            )
+        ],
+        depends_on=set(),
+    )
+    assert build_result[1] == ClassDefinition(
+        name="ObjectB",
+        properties=[
+            PropertyDefinition(
+                name="str_field", key="strField", value_type="str", known_type=True
+            )
+        ],
+        depends_on=set(),
+    )
@@ -2,6 +2,7 @@
 
 from danger_python.generator.models import (
     SchemaAllOf,
+    SchemaAnyOf,
     SchemaArray,
     SchemaEnum,
     SchemaObject,
@@ -166,6 +167,48 @@ def test_schema_parser_parses_multiple_type_definitions():
     )
 
 
+def test_schema_parser_parses_any_of_type():
+    """
+    Test schema parser parses any of type.
+    """
+    schema = """{
+        "$schema": "http://json-schema.org/draft-07/schema#",
+        "definitions": {
+            "AnyOfObject": {
+                "properties": {
+                    "user": {
+                        "anyOf": [
+                            {
+                                "$ref": "#/definitions/GitLabUser"
+                            },
+                            {
+                                "type": "null"
+                            }
+                        ]
+                    }
+                },
+                "type": "object"
+            }
+        }
+    }"""
+
+    definitions = parse_schema(schema)
+
+    assert len(definitions) == 1
+    assert definitions[0] == SchemaObject(
+        name="AnyOfObject",
+        properties=[
+            SchemaAnyOf(
+                name="user",
+                any_of=[
+                    SchemaReference(name="user", reference="GitLabUser"),
+                    SchemaValue(name="user", value_type="null"),
+                ],
+            )
+        ],
+    )
+
+
 def test_schema_parser_parses_real_schema():
     """
     Test schema parser parses real schema.