directive @goTag(
    key: String!
    value: String
) on INPUT_FIELD_DEFINITION | FIELD_DEFINITION

directive @goField(
	forceResolver: Boolean
	name: String
    omittable: Boolean
) on INPUT_FIELD_DEFINITION | FIELD_DEFINITION | INTERFACE

type Query {
    thisShoudlntGetGenerated: Boolean
}

type Mutation {
    thisShoudlntGetGenerated: Boolean
}

type Subscription {
    thisShoudlntGetGenerated: Boolean
}

type MissingTypeNotNull implements MissingInterface & ExistingInterface {
    name: String!
    enum: MissingEnum!
    int: MissingInterface!
    existing: ExistingType!
    missing2: MissingTypeNullable!
}

type MissingTypeNullable implements MissingInterface & ExistingInterface {
    name: String
    enum: MissingEnum
    int: MissingInterface
    existing: ExistingType
    missing2: MissingTypeNotNull
}

input MissingInput {
    name: String
    enum: MissingEnum
    nonNullString: String!
    nullString: String @goField(omittable: true)
    nullEnum: MissingEnum @goField(omittable: true)
    nullObject: ExistingInput @goField(omittable: true)
}

enum MissingEnum {
    Hello
    Goodbye
}

interface MissingInterface {
    name: String
}

union MissingUnion = MissingTypeNotNull | MissingTypeNullable | ExistingType

type ExistingType implements MissingInterface & ExistingInterface {
    name: String
    enum: ExistingEnum
    int: ExistingInterface
    existing: MissingTypeNullable
}

input ExistingInput {
    name: String
    enum: ExistingEnum
}

type FieldMutationHook {
    name: String @goTag(key :"anotherTag", value: "tag")
    enum: ExistingEnum @goTag(key: "yetAnotherTag", value: "12")
    noVal: String @goTag(key: "yaml") @goTag(key : "repeated", value: "true")
    repeated: String @goTag(key: "someTag", value: "value") @goTag(key : "repeated", value: "true")

}

enum ExistingEnum {
    Hello
    Goodbye
}

interface ExistingInterface {
    name: String
}

union ExistingUnion = MissingTypeNotNull | MissingTypeNullable  | ExistingType

"TypeWithDescription is a type with a description"
type TypeWithDescription {
    name: String
}

"EnumWithDescription is an enum with a description"
enum EnumWithDescription {
    CAT
    DOG
}

"InterfaceWithDescription is an interface with a description"
interface InterfaceWithDescription {
    name: String
}

"UnionWithDescription is an union with a description"
union UnionWithDescription = TypeWithDescription | ExistingType


interface Foo_Barer {
    name: String!
}

type _Foo_Barr implements  Foo_Barer {
    name: String!
}

# https://spec.graphql.org/October2021/#sec-Interfaces
interface A {
    a: String!
}

interface B {
    b: Int!
}

interface C implements A {
    a: String!
    c: Boolean!
}

interface D implements A & B {
    a: String!
    b: Int!
    d: String
}

type CDImplemented implements C & D & A & B {
    a: String!
    b: Int!
    c: Boolean!
    d: String
}

type CyclicalA {
    field_one: CyclicalB
    field_two: CyclicalB
    field_three: CyclicalB
    field_four: String!
}

type CyclicalB {
    field_one: CyclicalA
    field_two: CyclicalA
    field_three: CyclicalA
    field_four: CyclicalA
    field_five: String!
}

type NotCyclicalA {
    FieldOne: String!
    FieldTwo: Int!
}

type NotCyclicalB {
    FieldOne: String!
    FieldTwo: NotCyclicalA!
}

type Recursive {
    FieldOne: Recursive!
    FieldTwo: Recursive!
    FieldThree: Recursive!
    FieldFour: String!
}

type RenameFieldTest {
    badName: String!
    otherField: String!
}

interface ArrayOfA {
    trickyField: [A!]!
    trickyFieldPointer: [A]
}

type ImplArrayOfA implements ArrayOfA {
    trickyField: [CDImplemented!]!
    trickyFieldPointer: [CDImplemented]
}

interface X {
    Id: String! @goField(name: "Id")
}

type Xer implements X {
    Id: String! @goField(name: "Id")
    Name: String!
}

type ExtraFieldsTest {
  SchemaField: String!
}

type OmitEmptyJsonTagTest {
    ValueNonNil: String!
    Value: String
}