We are currently solving the following issue within our repository. Here is the issue text:
--- BEGIN ISSUE ---
Add test for/document interface type resolution
I switched over from graphene for a small test and have a hard time figuring out how to solve the

```
Abstract type NodeIface must resolve to an Object type at runtime for field Root.nodes with value <Node instance>, received 'None'. Either the NodeIface type should provide a \"resolve_type\" function or each possible type should provide an \"is_type_of\" function.
```

error message.

What I have so far is:

```python
@strawberry.interface
class NodeIface:
    uuid: strawberry.ID
    ctime: str
    mtime: str
    label: str

@strawberry.type
class Node(NodeIface):
    pass

@strawberry.type
class Calculation(NodeIface):
    attributes: CalculationAttributes
```

if I do something like:

```python
@strawberry.type
class Root:
    @strawberry.field
    def nodes(self, info) -> typing.List[typing.Union[Calculation, Node]]:
        # do a dispatch to the correct type here based on DB data
        def dispatch(dbobj):
            if dbobj.is_calculation:
                return Calculation(**dbobj)
            return Node(**dbobj)
        return [dispatch(dbobj) for dbobj in db.all()]
```

I can write a query like:

```graphql
{
  nodes {
    __typename
    ... on Calculation {
      attributes {
        processState
      }
    }
  }
}
```

but the following fails:

```graphql
{
  nodes {
    uuid
    __typename
    ... on Calculation {
      attributes {
        processState
      }
    }
  }
}
```

with

```
{
  "error": {
    "data": null,
    "errors": [
      {
        "message": "Cannot query field 'uuid' on type 'nodes'. Did you mean to use an inline fragment on 'NodeIface', 'Calculation' or 'Node'?",
        "locations": [
          {
            "line": 3,
            "column": 5
          }
        ],
        "path": null
      }
    ]
  }
}
```

On the other hand, when I use the interface as return type:

```
    @strawberry.field
    def nodes(self, info) -> typing.List[NodeIface]:
        # do a dispatch to the correct type here based on DB data
        def dispatch(dbobj):
            if dbobj.is_calculation:
                return Calculation(**dbobj)
            return Node(**dbobj)
        return [dispatch(dbobj) for dbobj in db.all()]
```

I get:

```
{
  "error": {
    "data": null,
    "errors": [
      {
        "message": "Abstract type NodeIface must resolve to an Object type at runtime for field Root.nodes with value <Node instance>, received 'None'. Either the NodeIface type should provide a \"resolve_type\" function or each possible type should provide an \"is_type_of\" function.",
        "locations": [
          {
            "line": 2,
            "column": 3
          }
        ],
        "path": [
          "nodes",
          0
        ]
      }
    ]
  }
}
```

but I am a bit at a loss here on where/how to specify that information. Especially since I'm under the impression that with the typing info this should in principle work out-of-the box.

--- END ISSUE ---

Below are some code segments, each from a relevant file. One or more of these files may contain bugs.
--- BEGIN FILES ---
Path: `strawberry/schema.py`
Content:
```
1 from graphql import GraphQLSchema
2 from graphql.type.directives import specified_directives
3 from graphql.utilities.schema_printer import print_schema
4 
5 
6 # TODO: typings
7 
8 
9 class Schema(GraphQLSchema):
10     def __init__(self, query, mutation=None, subscription=None, directives=()):
11         super().__init__(
12             query=query.field,
13             mutation=mutation.field if mutation else None,
14             subscription=subscription.field if subscription else None,
15             directives=specified_directives
16             + [directive.directive for directive in directives],
17         )
18 
19     def __repr__(self):
20         return print_schema(self)
21
```

Path: `strawberry/type.py`
Content:
```
1 from functools import partial
2 
3 import dataclasses
4 from graphql import GraphQLInputObjectType, GraphQLInterfaceType, GraphQLObjectType
5 
6 from .constants import IS_STRAWBERRY_FIELD, IS_STRAWBERRY_INPUT, IS_STRAWBERRY_INTERFACE
7 from .field import field, strawberry_field
8 from .type_converter import REGISTRY
9 from .utils.str_converters import to_camel_case
10 
11 
12 def _get_resolver(cls, field_name):
13     class_field = getattr(cls, field_name, None)
14 
15     if class_field and getattr(class_field, "resolver", None):
16         return class_field.resolver
17 
18     def _resolver(root, info):
19         field_resolver = getattr(root or cls(), field_name, None)
20 
21         if getattr(field_resolver, IS_STRAWBERRY_FIELD, False):
22             return field_resolver(root, info)
23 
24         elif field_resolver.__class__ is strawberry_field:
25             # TODO: support default values
26             return None
27 
28         return field_resolver
29 
30     return _resolver
31 
32 
33 def _process_type(cls, *, is_input=False, is_interface=False, description=None):
34     name = cls.__name__
35     REGISTRY[name] = cls
36 
37     def _get_fields(wrapped):
38         class_fields = dataclasses.fields(wrapped)
39 
40         fields = {}
41 
42         for class_field in class_fields:
43             field_name = getattr(class_field, "field_name", None) or to_camel_case(
44                 class_field.name
45             )
46             description = getattr(class_field, "field_description", None)
47 
48             resolver = getattr(class_field, "field_resolver", None) or _get_resolver(
49                 cls, class_field.name
50             )
51             resolver.__annotations__["return"] = class_field.type
52 
53             fields[field_name] = field(
54                 resolver, is_input=is_input, description=description
55             ).field
56 
57         strawberry_fields = {}
58 
59         for base in [cls, *cls.__bases__]:
60             strawberry_fields.update(
61                 {
62                     key: value
63                     for key, value in base.__dict__.items()
64                     if getattr(value, IS_STRAWBERRY_FIELD, False)
65                 }
66             )
67 
68         for key, value in strawberry_fields.items():
69             name = getattr(value, "field_name", None) or to_camel_case(key)
70 
71             fields[name] = value.field
72 
73         return fields
74 
75     if is_input:
76         setattr(cls, IS_STRAWBERRY_INPUT, True)
77     elif is_interface:
78         setattr(cls, IS_STRAWBERRY_INTERFACE, True)
79 
80     extra_kwargs = {"description": description or cls.__doc__}
81 
82     if is_input:
83         TypeClass = GraphQLInputObjectType
84     elif is_interface:
85         TypeClass = GraphQLInterfaceType
86     else:
87         TypeClass = GraphQLObjectType
88 
89         extra_kwargs["interfaces"] = [
90             klass.field
91             for klass in cls.__bases__
92             if hasattr(klass, IS_STRAWBERRY_INTERFACE)
93         ]
94 
95     wrapped = dataclasses.dataclass(cls)
96     wrapped.field = TypeClass(name, lambda: _get_fields(wrapped), **extra_kwargs)
97 
98     return wrapped
99 
100 
101 def type(cls=None, *, is_input=False, is_interface=False, description=None):
102     """Annotates a class as a GraphQL type.
103 
104     Example usage:
105 
106     >>> @strawberry.type:
107     >>> class X:
108     >>>     field_abc: str = "ABC"
109     """
110 
111     def wrap(cls):
112         return _process_type(
113             cls, is_input=is_input, is_interface=is_interface, description=description
114         )
115 
116     if cls is None:
117         return wrap
118 
119     return wrap(cls)
120 
121 
122 input = partial(type, is_input=True)
123 interface = partial(type, is_interface=True)
124
```
--- END FILES ---

Please first localize the bug based on the issue statement, and then generate a patch according to the `git diff` format fenced by three backticks.

Here is an example:

```diff
diff --git a/examples/server_async.py b/examples/server_async.py
--- a/examples/server_async.py
+++ b/examples/server_async.py
@@ -313,4 +313,4 @@
 
 
 if __name__ == "__main__":
-    asyncio.run(run_async_server("."), debug=True)
+    asyncio.run(run_async_server(), debug=True)
diff --git a/examples/server_sync.py b/examples/server_sync.py
--- a/examples/server_sync.py
+++ b/examples/server_sync.py
@@ -313,5 +313,5 @@
 
 
 if __name__ == "__main__":
-    server = run_sync_server(".")
+    server = run_sync_server()
     server.shutdown()

```

diff --git a/strawberry/schema.py b/strawberry/schema.py
--- a/strawberry/schema.py
+++ b/strawberry/schema.py
@@ -7,13 +7,28 @@
 
 
 class Schema(GraphQLSchema):
-    def __init__(self, query, mutation=None, subscription=None, directives=()):
+    def __init__(
+        self, query, mutation=None, subscription=None, directives=(), types=()
+    ):
+        """
+        Wrapper around the GraphQLSchema, but compatible
+        with Strawberry types and directives.
+
+        :param query: the root query to use for the schema
+        :param mutation: the basic mutation type (if any)
+        :param mutation: the subscription type (if any)
+        :param directives: (additional) Strawberry directives
+        :param types: additional Strawberry types to register, return values of fields
+                      are automatically registered while return types for interfaces have
+                      to be manually registered
+        """
         super().__init__(
             query=query.field,
             mutation=mutation.field if mutation else None,
             subscription=subscription.field if subscription else None,
             directives=specified_directives
             + [directive.directive for directive in directives],
+            types=[type.field for type in types],
         )
 
     def __repr__(self):
diff --git a/strawberry/type.py b/strawberry/type.py
--- a/strawberry/type.py
+++ b/strawberry/type.py
@@ -79,6 +79,8 @@
 
     extra_kwargs = {"description": description or cls.__doc__}
 
+    wrapped = dataclasses.dataclass(cls)
+
     if is_input:
         TypeClass = GraphQLInputObjectType
     elif is_interface:
@@ -92,7 +94,10 @@
             if hasattr(klass, IS_STRAWBERRY_INTERFACE)
         ]
 
-    wrapped = dataclasses.dataclass(cls)
+        # the user might want to register other classes,
+        # but for now let's just add our dataclass
+        extra_kwargs["is_type_of"] = lambda obj, _: isinstance(obj, wrapped)
+
     wrapped.field = TypeClass(name, lambda: _get_fields(wrapped), **extra_kwargs)
 
     return wrapped

{"golden_diff": "diff --git a/strawberry/schema.py b/strawberry/schema.py\n--- a/strawberry/schema.py\n+++ b/strawberry/schema.py\n@@ -7,13 +7,28 @@\n \n \n class Schema(GraphQLSchema):\n-    def __init__(self, query, mutation=None, subscription=None, directives=()):\n+    def __init__(\n+        self, query, mutation=None, subscription=None, directives=(), types=()\n+    ):\n+        \"\"\"\n+        Wrapper around the GraphQLSchema, but compatible\n+        with Strawberry types and directives.\n+\n+        :param query: the root query to use for the schema\n+        :param mutation: the basic mutation type (if any)\n+        :param mutation: the subscription type (if any)\n+        :param directives: (additional) Strawberry directives\n+        :param types: additional Strawberry types to register, return values of fields\n+                      are automatically registered while return types for interfaces have\n+                      to be manually registered\n+        \"\"\"\n         super().__init__(\n             query=query.field,\n             mutation=mutation.field if mutation else None,\n             subscription=subscription.field if subscription else None,\n             directives=specified_directives\n             + [directive.directive for directive in directives],\n+            types=[type.field for type in types],\n         )\n \n     def __repr__(self):\ndiff --git a/strawberry/type.py b/strawberry/type.py\n--- a/strawberry/type.py\n+++ b/strawberry/type.py\n@@ -79,6 +79,8 @@\n \n     extra_kwargs = {\"description\": description or cls.__doc__}\n \n+    wrapped = dataclasses.dataclass(cls)\n+\n     if is_input:\n         TypeClass = GraphQLInputObjectType\n     elif is_interface:\n@@ -92,7 +94,10 @@\n             if hasattr(klass, IS_STRAWBERRY_INTERFACE)\n         ]\n \n-    wrapped = dataclasses.dataclass(cls)\n+        # the user might want to register other classes,\n+        # but for now let's just add our dataclass\n+        extra_kwargs[\"is_type_of\"] = lambda obj, _: isinstance(obj, wrapped)\n+\n     wrapped.field = TypeClass(name, lambda: _get_fields(wrapped), **extra_kwargs)\n \n     return wrapped\n", "issue": "Add test for/document interface type resolution\nI switched over from graphene for a small test and have a hard time figuring out how to solve the\r\n\r\n```\r\nAbstract type NodeIface must resolve to an Object type at runtime for field Root.nodes with value <Node instance>, received 'None'. Either the NodeIface type should provide a \\\"resolve_type\\\" function or each possible type should provide an \\\"is_type_of\\\" function.\r\n```\r\n\r\nerror message.\r\n\r\nWhat I have so far is:\r\n\r\n```python\r\n@strawberry.interface\r\nclass NodeIface:\r\n    uuid: strawberry.ID\r\n    ctime: str\r\n    mtime: str\r\n    label: str\r\n\r\n@strawberry.type\r\nclass Node(NodeIface):\r\n    pass\r\n\r\n@strawberry.type\r\nclass Calculation(NodeIface):\r\n    attributes: CalculationAttributes\r\n```\r\n\r\nif I do something like:\r\n\r\n```python\r\n@strawberry.type\r\nclass Root:\r\n    @strawberry.field\r\n    def nodes(self, info) -> typing.List[typing.Union[Calculation, Node]]:\r\n        # do a dispatch to the correct type here based on DB data\r\n        def dispatch(dbobj):\r\n            if dbobj.is_calculation:\r\n                return Calculation(**dbobj)\r\n            return Node(**dbobj)\r\n        return [dispatch(dbobj) for dbobj in db.all()]\r\n```\r\n\r\nI can write a query like:\r\n\r\n```graphql\r\n{\r\n  nodes {\r\n    __typename\r\n    ... on Calculation {\r\n      attributes {\r\n        processState\r\n      }\r\n    }\r\n  }\r\n}\r\n```\r\n\r\nbut the following fails:\r\n\r\n```graphql\r\n{\r\n  nodes {\r\n    uuid\r\n    __typename\r\n    ... on Calculation {\r\n      attributes {\r\n        processState\r\n      }\r\n    }\r\n  }\r\n}\r\n```\r\n\r\nwith\r\n\r\n```\r\n{\r\n  \"error\": {\r\n    \"data\": null,\r\n    \"errors\": [\r\n      {\r\n        \"message\": \"Cannot query field 'uuid' on type 'nodes'. Did you mean to use an inline fragment on 'NodeIface', 'Calculation' or 'Node'?\",\r\n        \"locations\": [\r\n          {\r\n            \"line\": 3,\r\n            \"column\": 5\r\n          }\r\n        ],\r\n        \"path\": null\r\n      }\r\n    ]\r\n  }\r\n}\r\n```\r\n\r\nOn the other hand, when I use the interface as return type:\r\n\r\n```\r\n    @strawberry.field\r\n    def nodes(self, info) -> typing.List[NodeIface]:\r\n        # do a dispatch to the correct type here based on DB data\r\n        def dispatch(dbobj):\r\n            if dbobj.is_calculation:\r\n                return Calculation(**dbobj)\r\n            return Node(**dbobj)\r\n        return [dispatch(dbobj) for dbobj in db.all()]\r\n```\r\n\r\nI get:\r\n\r\n```\r\n{\r\n  \"error\": {\r\n    \"data\": null,\r\n    \"errors\": [\r\n      {\r\n        \"message\": \"Abstract type NodeIface must resolve to an Object type at runtime for field Root.nodes with value <Node instance>, received 'None'. Either the NodeIface type should provide a \\\"resolve_type\\\" function or each possible type should provide an \\\"is_type_of\\\" function.\",\r\n        \"locations\": [\r\n          {\r\n            \"line\": 2,\r\n            \"column\": 3\r\n          }\r\n        ],\r\n        \"path\": [\r\n          \"nodes\",\r\n          0\r\n        ]\r\n      }\r\n    ]\r\n  }\r\n}\r\n```\r\n\r\nbut I am a bit at a loss here on where/how to specify that information. Especially since I'm under the impression that with the typing info this should in principle work out-of-the box.\n", "before_files": [{"content": "from graphql import GraphQLSchema\nfrom graphql.type.directives import specified_directives\nfrom graphql.utilities.schema_printer import print_schema\n\n\n# TODO: typings\n\n\nclass Schema(GraphQLSchema):\n    def __init__(self, query, mutation=None, subscription=None, directives=()):\n        super().__init__(\n            query=query.field,\n            mutation=mutation.field if mutation else None,\n            subscription=subscription.field if subscription else None,\n            directives=specified_directives\n            + [directive.directive for directive in directives],\n        )\n\n    def __repr__(self):\n        return print_schema(self)\n", "path": "strawberry/schema.py"}, {"content": "from functools import partial\n\nimport dataclasses\nfrom graphql import GraphQLInputObjectType, GraphQLInterfaceType, GraphQLObjectType\n\nfrom .constants import IS_STRAWBERRY_FIELD, IS_STRAWBERRY_INPUT, IS_STRAWBERRY_INTERFACE\nfrom .field import field, strawberry_field\nfrom .type_converter import REGISTRY\nfrom .utils.str_converters import to_camel_case\n\n\ndef _get_resolver(cls, field_name):\n    class_field = getattr(cls, field_name, None)\n\n    if class_field and getattr(class_field, \"resolver\", None):\n        return class_field.resolver\n\n    def _resolver(root, info):\n        field_resolver = getattr(root or cls(), field_name, None)\n\n        if getattr(field_resolver, IS_STRAWBERRY_FIELD, False):\n            return field_resolver(root, info)\n\n        elif field_resolver.__class__ is strawberry_field:\n            # TODO: support default values\n            return None\n\n        return field_resolver\n\n    return _resolver\n\n\ndef _process_type(cls, *, is_input=False, is_interface=False, description=None):\n    name = cls.__name__\n    REGISTRY[name] = cls\n\n    def _get_fields(wrapped):\n        class_fields = dataclasses.fields(wrapped)\n\n        fields = {}\n\n        for class_field in class_fields:\n            field_name = getattr(class_field, \"field_name\", None) or to_camel_case(\n                class_field.name\n            )\n            description = getattr(class_field, \"field_description\", None)\n\n            resolver = getattr(class_field, \"field_resolver\", None) or _get_resolver(\n                cls, class_field.name\n            )\n            resolver.__annotations__[\"return\"] = class_field.type\n\n            fields[field_name] = field(\n                resolver, is_input=is_input, description=description\n            ).field\n\n        strawberry_fields = {}\n\n        for base in [cls, *cls.__bases__]:\n            strawberry_fields.update(\n                {\n                    key: value\n                    for key, value in base.__dict__.items()\n                    if getattr(value, IS_STRAWBERRY_FIELD, False)\n                }\n            )\n\n        for key, value in strawberry_fields.items():\n            name = getattr(value, \"field_name\", None) or to_camel_case(key)\n\n            fields[name] = value.field\n\n        return fields\n\n    if is_input:\n        setattr(cls, IS_STRAWBERRY_INPUT, True)\n    elif is_interface:\n        setattr(cls, IS_STRAWBERRY_INTERFACE, True)\n\n    extra_kwargs = {\"description\": description or cls.__doc__}\n\n    if is_input:\n        TypeClass = GraphQLInputObjectType\n    elif is_interface:\n        TypeClass = GraphQLInterfaceType\n    else:\n        TypeClass = GraphQLObjectType\n\n        extra_kwargs[\"interfaces\"] = [\n            klass.field\n            for klass in cls.__bases__\n            if hasattr(klass, IS_STRAWBERRY_INTERFACE)\n        ]\n\n    wrapped = dataclasses.dataclass(cls)\n    wrapped.field = TypeClass(name, lambda: _get_fields(wrapped), **extra_kwargs)\n\n    return wrapped\n\n\ndef type(cls=None, *, is_input=False, is_interface=False, description=None):\n    \"\"\"Annotates a class as a GraphQL type.\n\n    Example usage:\n\n    >>> @strawberry.type:\n    >>> class X:\n    >>>     field_abc: str = \"ABC\"\n    \"\"\"\n\n    def wrap(cls):\n        return _process_type(\n            cls, is_input=is_input, is_interface=is_interface, description=description\n        )\n\n    if cls is None:\n        return wrap\n\n    return wrap(cls)\n\n\ninput = partial(type, is_input=True)\ninterface = partial(type, is_interface=True)\n", "path": "strawberry/type.py"}], "after_files": [{"content": "from graphql import GraphQLSchema\nfrom graphql.type.directives import specified_directives\nfrom graphql.utilities.schema_printer import print_schema\n\n\n# TODO: typings\n\n\nclass Schema(GraphQLSchema):\n    def __init__(\n        self, query, mutation=None, subscription=None, directives=(), types=()\n    ):\n        \"\"\"\n        Wrapper around the GraphQLSchema, but compatible\n        with Strawberry types and directives.\n\n        :param query: the root query to use for the schema\n        :param mutation: the basic mutation type (if any)\n        :param mutation: the subscription type (if any)\n        :param directives: (additional) Strawberry directives\n        :param types: additional Strawberry types to register, return values of fields\n                      are automatically registered while return types for interfaces have\n                      to be manually registered\n        \"\"\"\n        super().__init__(\n            query=query.field,\n            mutation=mutation.field if mutation else None,\n            subscription=subscription.field if subscription else None,\n            directives=specified_directives\n            + [directive.directive for directive in directives],\n            types=[type.field for type in types],\n        )\n\n    def __repr__(self):\n        return print_schema(self)\n", "path": "strawberry/schema.py"}, {"content": "from functools import partial\n\nimport dataclasses\nfrom graphql import GraphQLInputObjectType, GraphQLInterfaceType, GraphQLObjectType\n\nfrom .constants import IS_STRAWBERRY_FIELD, IS_STRAWBERRY_INPUT, IS_STRAWBERRY_INTERFACE\nfrom .field import field, strawberry_field\nfrom .type_converter import REGISTRY\nfrom .utils.str_converters import to_camel_case\n\n\ndef _get_resolver(cls, field_name):\n    class_field = getattr(cls, field_name, None)\n\n    if class_field and getattr(class_field, \"resolver\", None):\n        return class_field.resolver\n\n    def _resolver(root, info):\n        field_resolver = getattr(root or cls(), field_name, None)\n\n        if getattr(field_resolver, IS_STRAWBERRY_FIELD, False):\n            return field_resolver(root, info)\n\n        elif field_resolver.__class__ is strawberry_field:\n            # TODO: support default values\n            return None\n\n        return field_resolver\n\n    return _resolver\n\n\ndef _process_type(cls, *, is_input=False, is_interface=False, description=None):\n    name = cls.__name__\n    REGISTRY[name] = cls\n\n    def _get_fields(wrapped):\n        class_fields = dataclasses.fields(wrapped)\n\n        fields = {}\n\n        for class_field in class_fields:\n            field_name = getattr(class_field, \"field_name\", None) or to_camel_case(\n                class_field.name\n            )\n            description = getattr(class_field, \"field_description\", None)\n\n            resolver = getattr(class_field, \"field_resolver\", None) or _get_resolver(\n                cls, class_field.name\n            )\n            resolver.__annotations__[\"return\"] = class_field.type\n\n            fields[field_name] = field(\n                resolver, is_input=is_input, description=description\n            ).field\n\n        strawberry_fields = {}\n\n        for base in [cls, *cls.__bases__]:\n            strawberry_fields.update(\n                {\n                    key: value\n                    for key, value in base.__dict__.items()\n                    if getattr(value, IS_STRAWBERRY_FIELD, False)\n                }\n            )\n\n        for key, value in strawberry_fields.items():\n            name = getattr(value, \"field_name\", None) or to_camel_case(key)\n\n            fields[name] = value.field\n\n        return fields\n\n    if is_input:\n        setattr(cls, IS_STRAWBERRY_INPUT, True)\n    elif is_interface:\n        setattr(cls, IS_STRAWBERRY_INTERFACE, True)\n\n    extra_kwargs = {\"description\": description or cls.__doc__}\n\n    wrapped = dataclasses.dataclass(cls)\n\n    if is_input:\n        TypeClass = GraphQLInputObjectType\n    elif is_interface:\n        TypeClass = GraphQLInterfaceType\n    else:\n        TypeClass = GraphQLObjectType\n\n        extra_kwargs[\"interfaces\"] = [\n            klass.field\n            for klass in cls.__bases__\n            if hasattr(klass, IS_STRAWBERRY_INTERFACE)\n        ]\n\n        # the user might want to register other classes,\n        # but for now let's just add our dataclass\n        extra_kwargs[\"is_type_of\"] = lambda obj, _: isinstance(obj, wrapped)\n\n    wrapped.field = TypeClass(name, lambda: _get_fields(wrapped), **extra_kwargs)\n\n    return wrapped\n\n\ndef type(cls=None, *, is_input=False, is_interface=False, description=None):\n    \"\"\"Annotates a class as a GraphQL type.\n\n    Example usage:\n\n    >>> @strawberry.type:\n    >>> class X:\n    >>>     field_abc: str = \"ABC\"\n    \"\"\"\n\n    def wrap(cls):\n        return _process_type(\n            cls, is_input=is_input, is_interface=is_interface, description=description\n        )\n\n    if cls is None:\n        return wrap\n\n    return wrap(cls)\n\n\ninput = partial(type, is_input=True)\ninterface = partial(type, is_interface=True)\n", "path": "strawberry/type.py"}]}