extend type Query {
    shapes: [Shape]
    noShape: Shape @makeNil
    node: Node!
    noShapeTypedNil: Shape @makeTypedNil
    animal: Animal @makeTypedNil
    notAnInterface: BackedByInterface
    dog: Dog
}

interface Animal {
    species: String!
    size: Size!
}

type Size {
    height: Int!
    weight: Int!
}

type BackedByInterface {
    id: String!
    thisShouldBind: String!
    thisShouldBindWithError: String!
}

type Dog implements Animal {
    species: String!
    size: Size!
    dogBreed: String!
}

type Cat implements Animal {
    species: String!
    size: Size!
    catBreed: String!
}

type Coordinates {
    x: Float!
    y: Float!
}
interface Shape {
    area: Float
    coordinates: Coordinates
}

type Circle implements Shape {
    radius: Float
    area: Float
    coordinates: Coordinates
}
type Rectangle implements Shape {
    length: Float
    width: Float
    area: Float
    coordinates: Coordinates
}
union ShapeUnion @goModel(model: "followschema.ShapeUnion") = Circle | Rectangle

directive @makeNil on FIELD_DEFINITION
directive @makeTypedNil on FIELD_DEFINITION

interface Node {
    id: ID!
    child: Node!
}

type ConcreteNodeA implements Node {
    id: ID!
    child: Node!
    name: String!
}

" Implements the Node interface with another interface "
type ConcreteNodeInterface implements Node {
    id: ID!
    child: Node!
}

interface Mammalian implements Animal {
    species: String!
    size: Size!
}

# Types with multiple interfaces are evaluated first in the case statement
type Horse implements Mammalian & Animal {
    species: String!
    size: Size!
    horseBreed: String!
}