1// Code generated by github.com/99designs/gqlgen, DO NOT EDIT.
   2
   3package graph
   4
   5import (
   6	"context"
   7	"errors"
   8	"fmt"
   9	"strconv"
  10	"sync"
  11	"sync/atomic"
  12
  13	"github.com/99designs/gqlgen/graphql"
  14	"github.com/99designs/gqlgen/graphql/introspection"
  15	"github.com/git-bug/git-bug/entity"
  16	"github.com/vektah/gqlparser/v2/ast"
  17)
  18
  19// region    ************************** generated!.gotpl **************************
  20
  21// endregion ************************** generated!.gotpl **************************
  22
  23// region    ***************************** args.gotpl *****************************
  24
  25func (ec *executionContext) dir_defer_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
  26	var err error
  27	args := map[string]interface{}{}
  28	var arg0 *bool
  29	if tmp, ok := rawArgs["if"]; ok {
  30		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("if"))
  31		arg0, err = ec.unmarshalOBoolean2ᚖbool(ctx, tmp)
  32		if err != nil {
  33			return nil, err
  34		}
  35	}
  36	args["if"] = arg0
  37	var arg1 *string
  38	if tmp, ok := rawArgs["label"]; ok {
  39		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("label"))
  40		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
  41		if err != nil {
  42			return nil, err
  43		}
  44	}
  45	args["label"] = arg1
  46	return args, nil
  47}
  48
  49func (ec *executionContext) field___Type_enumValues_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
  50	var err error
  51	args := map[string]interface{}{}
  52	var arg0 bool
  53	if tmp, ok := rawArgs["includeDeprecated"]; ok {
  54		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("includeDeprecated"))
  55		arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
  56		if err != nil {
  57			return nil, err
  58		}
  59	}
  60	args["includeDeprecated"] = arg0
  61	return args, nil
  62}
  63
  64func (ec *executionContext) field___Type_fields_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
  65	var err error
  66	args := map[string]interface{}{}
  67	var arg0 bool
  68	if tmp, ok := rawArgs["includeDeprecated"]; ok {
  69		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("includeDeprecated"))
  70		arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
  71		if err != nil {
  72			return nil, err
  73		}
  74	}
  75	args["includeDeprecated"] = arg0
  76	return args, nil
  77}
  78
  79// endregion ***************************** args.gotpl *****************************
  80
  81// region    ************************** directives.gotpl **************************
  82
  83// endregion ************************** directives.gotpl **************************
  84
  85// region    **************************** field.gotpl *****************************
  86
  87func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
  88	fc, err := ec.fieldContext___Directive_name(ctx, field)
  89	if err != nil {
  90		return graphql.Null
  91	}
  92	ctx = graphql.WithFieldContext(ctx, fc)
  93	defer func() {
  94		if r := recover(); r != nil {
  95			ec.Error(ctx, ec.Recover(ctx, r))
  96			ret = graphql.Null
  97		}
  98	}()
  99	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 100		ctx = rctx // use context from middleware stack in children
 101		return obj.Name, nil
 102	})
 103	if err != nil {
 104		ec.Error(ctx, err)
 105		return graphql.Null
 106	}
 107	if resTmp == nil {
 108		if !graphql.HasFieldError(ctx, fc) {
 109			ec.Errorf(ctx, "must not be null")
 110		}
 111		return graphql.Null
 112	}
 113	res := resTmp.(string)
 114	fc.Result = res
 115	return ec.marshalNString2string(ctx, field.Selections, res)
 116}
 117
 118func (ec *executionContext) fieldContext___Directive_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 119	fc = &graphql.FieldContext{
 120		Object:     "__Directive",
 121		Field:      field,
 122		IsMethod:   false,
 123		IsResolver: false,
 124		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 125			return nil, errors.New("field of type String does not have child fields")
 126		},
 127	}
 128	return fc, nil
 129}
 130
 131func (ec *executionContext) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
 132	fc, err := ec.fieldContext___Directive_description(ctx, field)
 133	if err != nil {
 134		return graphql.Null
 135	}
 136	ctx = graphql.WithFieldContext(ctx, fc)
 137	defer func() {
 138		if r := recover(); r != nil {
 139			ec.Error(ctx, ec.Recover(ctx, r))
 140			ret = graphql.Null
 141		}
 142	}()
 143	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 144		ctx = rctx // use context from middleware stack in children
 145		return obj.Description(), nil
 146	})
 147	if err != nil {
 148		ec.Error(ctx, err)
 149		return graphql.Null
 150	}
 151	if resTmp == nil {
 152		return graphql.Null
 153	}
 154	res := resTmp.(*string)
 155	fc.Result = res
 156	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 157}
 158
 159func (ec *executionContext) fieldContext___Directive_description(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 160	fc = &graphql.FieldContext{
 161		Object:     "__Directive",
 162		Field:      field,
 163		IsMethod:   true,
 164		IsResolver: false,
 165		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 166			return nil, errors.New("field of type String does not have child fields")
 167		},
 168	}
 169	return fc, nil
 170}
 171
 172func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
 173	fc, err := ec.fieldContext___Directive_locations(ctx, field)
 174	if err != nil {
 175		return graphql.Null
 176	}
 177	ctx = graphql.WithFieldContext(ctx, fc)
 178	defer func() {
 179		if r := recover(); r != nil {
 180			ec.Error(ctx, ec.Recover(ctx, r))
 181			ret = graphql.Null
 182		}
 183	}()
 184	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 185		ctx = rctx // use context from middleware stack in children
 186		return obj.Locations, nil
 187	})
 188	if err != nil {
 189		ec.Error(ctx, err)
 190		return graphql.Null
 191	}
 192	if resTmp == nil {
 193		if !graphql.HasFieldError(ctx, fc) {
 194			ec.Errorf(ctx, "must not be null")
 195		}
 196		return graphql.Null
 197	}
 198	res := resTmp.([]string)
 199	fc.Result = res
 200	return ec.marshalN__DirectiveLocation2ᚕstringᚄ(ctx, field.Selections, res)
 201}
 202
 203func (ec *executionContext) fieldContext___Directive_locations(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 204	fc = &graphql.FieldContext{
 205		Object:     "__Directive",
 206		Field:      field,
 207		IsMethod:   false,
 208		IsResolver: false,
 209		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 210			return nil, errors.New("field of type __DirectiveLocation does not have child fields")
 211		},
 212	}
 213	return fc, nil
 214}
 215
 216func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
 217	fc, err := ec.fieldContext___Directive_args(ctx, field)
 218	if err != nil {
 219		return graphql.Null
 220	}
 221	ctx = graphql.WithFieldContext(ctx, fc)
 222	defer func() {
 223		if r := recover(); r != nil {
 224			ec.Error(ctx, ec.Recover(ctx, r))
 225			ret = graphql.Null
 226		}
 227	}()
 228	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 229		ctx = rctx // use context from middleware stack in children
 230		return obj.Args, nil
 231	})
 232	if err != nil {
 233		ec.Error(ctx, err)
 234		return graphql.Null
 235	}
 236	if resTmp == nil {
 237		if !graphql.HasFieldError(ctx, fc) {
 238			ec.Errorf(ctx, "must not be null")
 239		}
 240		return graphql.Null
 241	}
 242	res := resTmp.([]introspection.InputValue)
 243	fc.Result = res
 244	return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
 245}
 246
 247func (ec *executionContext) fieldContext___Directive_args(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 248	fc = &graphql.FieldContext{
 249		Object:     "__Directive",
 250		Field:      field,
 251		IsMethod:   false,
 252		IsResolver: false,
 253		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 254			switch field.Name {
 255			case "name":
 256				return ec.fieldContext___InputValue_name(ctx, field)
 257			case "description":
 258				return ec.fieldContext___InputValue_description(ctx, field)
 259			case "type":
 260				return ec.fieldContext___InputValue_type(ctx, field)
 261			case "defaultValue":
 262				return ec.fieldContext___InputValue_defaultValue(ctx, field)
 263			}
 264			return nil, fmt.Errorf("no field named %q was found under type __InputValue", field.Name)
 265		},
 266	}
 267	return fc, nil
 268}
 269
 270func (ec *executionContext) ___Directive_isRepeatable(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
 271	fc, err := ec.fieldContext___Directive_isRepeatable(ctx, field)
 272	if err != nil {
 273		return graphql.Null
 274	}
 275	ctx = graphql.WithFieldContext(ctx, fc)
 276	defer func() {
 277		if r := recover(); r != nil {
 278			ec.Error(ctx, ec.Recover(ctx, r))
 279			ret = graphql.Null
 280		}
 281	}()
 282	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 283		ctx = rctx // use context from middleware stack in children
 284		return obj.IsRepeatable, nil
 285	})
 286	if err != nil {
 287		ec.Error(ctx, err)
 288		return graphql.Null
 289	}
 290	if resTmp == nil {
 291		if !graphql.HasFieldError(ctx, fc) {
 292			ec.Errorf(ctx, "must not be null")
 293		}
 294		return graphql.Null
 295	}
 296	res := resTmp.(bool)
 297	fc.Result = res
 298	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 299}
 300
 301func (ec *executionContext) fieldContext___Directive_isRepeatable(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 302	fc = &graphql.FieldContext{
 303		Object:     "__Directive",
 304		Field:      field,
 305		IsMethod:   false,
 306		IsResolver: false,
 307		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 308			return nil, errors.New("field of type Boolean does not have child fields")
 309		},
 310	}
 311	return fc, nil
 312}
 313
 314func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
 315	fc, err := ec.fieldContext___EnumValue_name(ctx, field)
 316	if err != nil {
 317		return graphql.Null
 318	}
 319	ctx = graphql.WithFieldContext(ctx, fc)
 320	defer func() {
 321		if r := recover(); r != nil {
 322			ec.Error(ctx, ec.Recover(ctx, r))
 323			ret = graphql.Null
 324		}
 325	}()
 326	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 327		ctx = rctx // use context from middleware stack in children
 328		return obj.Name, nil
 329	})
 330	if err != nil {
 331		ec.Error(ctx, err)
 332		return graphql.Null
 333	}
 334	if resTmp == nil {
 335		if !graphql.HasFieldError(ctx, fc) {
 336			ec.Errorf(ctx, "must not be null")
 337		}
 338		return graphql.Null
 339	}
 340	res := resTmp.(string)
 341	fc.Result = res
 342	return ec.marshalNString2string(ctx, field.Selections, res)
 343}
 344
 345func (ec *executionContext) fieldContext___EnumValue_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 346	fc = &graphql.FieldContext{
 347		Object:     "__EnumValue",
 348		Field:      field,
 349		IsMethod:   false,
 350		IsResolver: false,
 351		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 352			return nil, errors.New("field of type String does not have child fields")
 353		},
 354	}
 355	return fc, nil
 356}
 357
 358func (ec *executionContext) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
 359	fc, err := ec.fieldContext___EnumValue_description(ctx, field)
 360	if err != nil {
 361		return graphql.Null
 362	}
 363	ctx = graphql.WithFieldContext(ctx, fc)
 364	defer func() {
 365		if r := recover(); r != nil {
 366			ec.Error(ctx, ec.Recover(ctx, r))
 367			ret = graphql.Null
 368		}
 369	}()
 370	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 371		ctx = rctx // use context from middleware stack in children
 372		return obj.Description(), nil
 373	})
 374	if err != nil {
 375		ec.Error(ctx, err)
 376		return graphql.Null
 377	}
 378	if resTmp == nil {
 379		return graphql.Null
 380	}
 381	res := resTmp.(*string)
 382	fc.Result = res
 383	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 384}
 385
 386func (ec *executionContext) fieldContext___EnumValue_description(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 387	fc = &graphql.FieldContext{
 388		Object:     "__EnumValue",
 389		Field:      field,
 390		IsMethod:   true,
 391		IsResolver: false,
 392		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 393			return nil, errors.New("field of type String does not have child fields")
 394		},
 395	}
 396	return fc, nil
 397}
 398
 399func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
 400	fc, err := ec.fieldContext___EnumValue_isDeprecated(ctx, field)
 401	if err != nil {
 402		return graphql.Null
 403	}
 404	ctx = graphql.WithFieldContext(ctx, fc)
 405	defer func() {
 406		if r := recover(); r != nil {
 407			ec.Error(ctx, ec.Recover(ctx, r))
 408			ret = graphql.Null
 409		}
 410	}()
 411	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 412		ctx = rctx // use context from middleware stack in children
 413		return obj.IsDeprecated(), nil
 414	})
 415	if err != nil {
 416		ec.Error(ctx, err)
 417		return graphql.Null
 418	}
 419	if resTmp == nil {
 420		if !graphql.HasFieldError(ctx, fc) {
 421			ec.Errorf(ctx, "must not be null")
 422		}
 423		return graphql.Null
 424	}
 425	res := resTmp.(bool)
 426	fc.Result = res
 427	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 428}
 429
 430func (ec *executionContext) fieldContext___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 431	fc = &graphql.FieldContext{
 432		Object:     "__EnumValue",
 433		Field:      field,
 434		IsMethod:   true,
 435		IsResolver: false,
 436		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 437			return nil, errors.New("field of type Boolean does not have child fields")
 438		},
 439	}
 440	return fc, nil
 441}
 442
 443func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
 444	fc, err := ec.fieldContext___EnumValue_deprecationReason(ctx, field)
 445	if err != nil {
 446		return graphql.Null
 447	}
 448	ctx = graphql.WithFieldContext(ctx, fc)
 449	defer func() {
 450		if r := recover(); r != nil {
 451			ec.Error(ctx, ec.Recover(ctx, r))
 452			ret = graphql.Null
 453		}
 454	}()
 455	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 456		ctx = rctx // use context from middleware stack in children
 457		return obj.DeprecationReason(), nil
 458	})
 459	if err != nil {
 460		ec.Error(ctx, err)
 461		return graphql.Null
 462	}
 463	if resTmp == nil {
 464		return graphql.Null
 465	}
 466	res := resTmp.(*string)
 467	fc.Result = res
 468	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 469}
 470
 471func (ec *executionContext) fieldContext___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 472	fc = &graphql.FieldContext{
 473		Object:     "__EnumValue",
 474		Field:      field,
 475		IsMethod:   true,
 476		IsResolver: false,
 477		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 478			return nil, errors.New("field of type String does not have child fields")
 479		},
 480	}
 481	return fc, nil
 482}
 483
 484func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
 485	fc, err := ec.fieldContext___Field_name(ctx, field)
 486	if err != nil {
 487		return graphql.Null
 488	}
 489	ctx = graphql.WithFieldContext(ctx, fc)
 490	defer func() {
 491		if r := recover(); r != nil {
 492			ec.Error(ctx, ec.Recover(ctx, r))
 493			ret = graphql.Null
 494		}
 495	}()
 496	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 497		ctx = rctx // use context from middleware stack in children
 498		return obj.Name, nil
 499	})
 500	if err != nil {
 501		ec.Error(ctx, err)
 502		return graphql.Null
 503	}
 504	if resTmp == nil {
 505		if !graphql.HasFieldError(ctx, fc) {
 506			ec.Errorf(ctx, "must not be null")
 507		}
 508		return graphql.Null
 509	}
 510	res := resTmp.(string)
 511	fc.Result = res
 512	return ec.marshalNString2string(ctx, field.Selections, res)
 513}
 514
 515func (ec *executionContext) fieldContext___Field_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 516	fc = &graphql.FieldContext{
 517		Object:     "__Field",
 518		Field:      field,
 519		IsMethod:   false,
 520		IsResolver: false,
 521		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 522			return nil, errors.New("field of type String does not have child fields")
 523		},
 524	}
 525	return fc, nil
 526}
 527
 528func (ec *executionContext) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
 529	fc, err := ec.fieldContext___Field_description(ctx, field)
 530	if err != nil {
 531		return graphql.Null
 532	}
 533	ctx = graphql.WithFieldContext(ctx, fc)
 534	defer func() {
 535		if r := recover(); r != nil {
 536			ec.Error(ctx, ec.Recover(ctx, r))
 537			ret = graphql.Null
 538		}
 539	}()
 540	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 541		ctx = rctx // use context from middleware stack in children
 542		return obj.Description(), nil
 543	})
 544	if err != nil {
 545		ec.Error(ctx, err)
 546		return graphql.Null
 547	}
 548	if resTmp == nil {
 549		return graphql.Null
 550	}
 551	res := resTmp.(*string)
 552	fc.Result = res
 553	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 554}
 555
 556func (ec *executionContext) fieldContext___Field_description(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 557	fc = &graphql.FieldContext{
 558		Object:     "__Field",
 559		Field:      field,
 560		IsMethod:   true,
 561		IsResolver: false,
 562		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 563			return nil, errors.New("field of type String does not have child fields")
 564		},
 565	}
 566	return fc, nil
 567}
 568
 569func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
 570	fc, err := ec.fieldContext___Field_args(ctx, field)
 571	if err != nil {
 572		return graphql.Null
 573	}
 574	ctx = graphql.WithFieldContext(ctx, fc)
 575	defer func() {
 576		if r := recover(); r != nil {
 577			ec.Error(ctx, ec.Recover(ctx, r))
 578			ret = graphql.Null
 579		}
 580	}()
 581	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 582		ctx = rctx // use context from middleware stack in children
 583		return obj.Args, nil
 584	})
 585	if err != nil {
 586		ec.Error(ctx, err)
 587		return graphql.Null
 588	}
 589	if resTmp == nil {
 590		if !graphql.HasFieldError(ctx, fc) {
 591			ec.Errorf(ctx, "must not be null")
 592		}
 593		return graphql.Null
 594	}
 595	res := resTmp.([]introspection.InputValue)
 596	fc.Result = res
 597	return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
 598}
 599
 600func (ec *executionContext) fieldContext___Field_args(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 601	fc = &graphql.FieldContext{
 602		Object:     "__Field",
 603		Field:      field,
 604		IsMethod:   false,
 605		IsResolver: false,
 606		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 607			switch field.Name {
 608			case "name":
 609				return ec.fieldContext___InputValue_name(ctx, field)
 610			case "description":
 611				return ec.fieldContext___InputValue_description(ctx, field)
 612			case "type":
 613				return ec.fieldContext___InputValue_type(ctx, field)
 614			case "defaultValue":
 615				return ec.fieldContext___InputValue_defaultValue(ctx, field)
 616			}
 617			return nil, fmt.Errorf("no field named %q was found under type __InputValue", field.Name)
 618		},
 619	}
 620	return fc, nil
 621}
 622
 623func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
 624	fc, err := ec.fieldContext___Field_type(ctx, field)
 625	if err != nil {
 626		return graphql.Null
 627	}
 628	ctx = graphql.WithFieldContext(ctx, fc)
 629	defer func() {
 630		if r := recover(); r != nil {
 631			ec.Error(ctx, ec.Recover(ctx, r))
 632			ret = graphql.Null
 633		}
 634	}()
 635	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 636		ctx = rctx // use context from middleware stack in children
 637		return obj.Type, nil
 638	})
 639	if err != nil {
 640		ec.Error(ctx, err)
 641		return graphql.Null
 642	}
 643	if resTmp == nil {
 644		if !graphql.HasFieldError(ctx, fc) {
 645			ec.Errorf(ctx, "must not be null")
 646		}
 647		return graphql.Null
 648	}
 649	res := resTmp.(*introspection.Type)
 650	fc.Result = res
 651	return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
 652}
 653
 654func (ec *executionContext) fieldContext___Field_type(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 655	fc = &graphql.FieldContext{
 656		Object:     "__Field",
 657		Field:      field,
 658		IsMethod:   false,
 659		IsResolver: false,
 660		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 661			switch field.Name {
 662			case "kind":
 663				return ec.fieldContext___Type_kind(ctx, field)
 664			case "name":
 665				return ec.fieldContext___Type_name(ctx, field)
 666			case "description":
 667				return ec.fieldContext___Type_description(ctx, field)
 668			case "fields":
 669				return ec.fieldContext___Type_fields(ctx, field)
 670			case "interfaces":
 671				return ec.fieldContext___Type_interfaces(ctx, field)
 672			case "possibleTypes":
 673				return ec.fieldContext___Type_possibleTypes(ctx, field)
 674			case "enumValues":
 675				return ec.fieldContext___Type_enumValues(ctx, field)
 676			case "inputFields":
 677				return ec.fieldContext___Type_inputFields(ctx, field)
 678			case "ofType":
 679				return ec.fieldContext___Type_ofType(ctx, field)
 680			case "specifiedByURL":
 681				return ec.fieldContext___Type_specifiedByURL(ctx, field)
 682			}
 683			return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
 684		},
 685	}
 686	return fc, nil
 687}
 688
 689func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
 690	fc, err := ec.fieldContext___Field_isDeprecated(ctx, field)
 691	if err != nil {
 692		return graphql.Null
 693	}
 694	ctx = graphql.WithFieldContext(ctx, fc)
 695	defer func() {
 696		if r := recover(); r != nil {
 697			ec.Error(ctx, ec.Recover(ctx, r))
 698			ret = graphql.Null
 699		}
 700	}()
 701	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 702		ctx = rctx // use context from middleware stack in children
 703		return obj.IsDeprecated(), nil
 704	})
 705	if err != nil {
 706		ec.Error(ctx, err)
 707		return graphql.Null
 708	}
 709	if resTmp == nil {
 710		if !graphql.HasFieldError(ctx, fc) {
 711			ec.Errorf(ctx, "must not be null")
 712		}
 713		return graphql.Null
 714	}
 715	res := resTmp.(bool)
 716	fc.Result = res
 717	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 718}
 719
 720func (ec *executionContext) fieldContext___Field_isDeprecated(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 721	fc = &graphql.FieldContext{
 722		Object:     "__Field",
 723		Field:      field,
 724		IsMethod:   true,
 725		IsResolver: false,
 726		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 727			return nil, errors.New("field of type Boolean does not have child fields")
 728		},
 729	}
 730	return fc, nil
 731}
 732
 733func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
 734	fc, err := ec.fieldContext___Field_deprecationReason(ctx, field)
 735	if err != nil {
 736		return graphql.Null
 737	}
 738	ctx = graphql.WithFieldContext(ctx, fc)
 739	defer func() {
 740		if r := recover(); r != nil {
 741			ec.Error(ctx, ec.Recover(ctx, r))
 742			ret = graphql.Null
 743		}
 744	}()
 745	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 746		ctx = rctx // use context from middleware stack in children
 747		return obj.DeprecationReason(), nil
 748	})
 749	if err != nil {
 750		ec.Error(ctx, err)
 751		return graphql.Null
 752	}
 753	if resTmp == nil {
 754		return graphql.Null
 755	}
 756	res := resTmp.(*string)
 757	fc.Result = res
 758	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 759}
 760
 761func (ec *executionContext) fieldContext___Field_deprecationReason(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 762	fc = &graphql.FieldContext{
 763		Object:     "__Field",
 764		Field:      field,
 765		IsMethod:   true,
 766		IsResolver: false,
 767		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 768			return nil, errors.New("field of type String does not have child fields")
 769		},
 770	}
 771	return fc, nil
 772}
 773
 774func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
 775	fc, err := ec.fieldContext___InputValue_name(ctx, field)
 776	if err != nil {
 777		return graphql.Null
 778	}
 779	ctx = graphql.WithFieldContext(ctx, fc)
 780	defer func() {
 781		if r := recover(); r != nil {
 782			ec.Error(ctx, ec.Recover(ctx, r))
 783			ret = graphql.Null
 784		}
 785	}()
 786	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 787		ctx = rctx // use context from middleware stack in children
 788		return obj.Name, nil
 789	})
 790	if err != nil {
 791		ec.Error(ctx, err)
 792		return graphql.Null
 793	}
 794	if resTmp == nil {
 795		if !graphql.HasFieldError(ctx, fc) {
 796			ec.Errorf(ctx, "must not be null")
 797		}
 798		return graphql.Null
 799	}
 800	res := resTmp.(string)
 801	fc.Result = res
 802	return ec.marshalNString2string(ctx, field.Selections, res)
 803}
 804
 805func (ec *executionContext) fieldContext___InputValue_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 806	fc = &graphql.FieldContext{
 807		Object:     "__InputValue",
 808		Field:      field,
 809		IsMethod:   false,
 810		IsResolver: false,
 811		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 812			return nil, errors.New("field of type String does not have child fields")
 813		},
 814	}
 815	return fc, nil
 816}
 817
 818func (ec *executionContext) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
 819	fc, err := ec.fieldContext___InputValue_description(ctx, field)
 820	if err != nil {
 821		return graphql.Null
 822	}
 823	ctx = graphql.WithFieldContext(ctx, fc)
 824	defer func() {
 825		if r := recover(); r != nil {
 826			ec.Error(ctx, ec.Recover(ctx, r))
 827			ret = graphql.Null
 828		}
 829	}()
 830	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 831		ctx = rctx // use context from middleware stack in children
 832		return obj.Description(), nil
 833	})
 834	if err != nil {
 835		ec.Error(ctx, err)
 836		return graphql.Null
 837	}
 838	if resTmp == nil {
 839		return graphql.Null
 840	}
 841	res := resTmp.(*string)
 842	fc.Result = res
 843	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 844}
 845
 846func (ec *executionContext) fieldContext___InputValue_description(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 847	fc = &graphql.FieldContext{
 848		Object:     "__InputValue",
 849		Field:      field,
 850		IsMethod:   true,
 851		IsResolver: false,
 852		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 853			return nil, errors.New("field of type String does not have child fields")
 854		},
 855	}
 856	return fc, nil
 857}
 858
 859func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
 860	fc, err := ec.fieldContext___InputValue_type(ctx, field)
 861	if err != nil {
 862		return graphql.Null
 863	}
 864	ctx = graphql.WithFieldContext(ctx, fc)
 865	defer func() {
 866		if r := recover(); r != nil {
 867			ec.Error(ctx, ec.Recover(ctx, r))
 868			ret = graphql.Null
 869		}
 870	}()
 871	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 872		ctx = rctx // use context from middleware stack in children
 873		return obj.Type, nil
 874	})
 875	if err != nil {
 876		ec.Error(ctx, err)
 877		return graphql.Null
 878	}
 879	if resTmp == nil {
 880		if !graphql.HasFieldError(ctx, fc) {
 881			ec.Errorf(ctx, "must not be null")
 882		}
 883		return graphql.Null
 884	}
 885	res := resTmp.(*introspection.Type)
 886	fc.Result = res
 887	return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
 888}
 889
 890func (ec *executionContext) fieldContext___InputValue_type(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 891	fc = &graphql.FieldContext{
 892		Object:     "__InputValue",
 893		Field:      field,
 894		IsMethod:   false,
 895		IsResolver: false,
 896		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 897			switch field.Name {
 898			case "kind":
 899				return ec.fieldContext___Type_kind(ctx, field)
 900			case "name":
 901				return ec.fieldContext___Type_name(ctx, field)
 902			case "description":
 903				return ec.fieldContext___Type_description(ctx, field)
 904			case "fields":
 905				return ec.fieldContext___Type_fields(ctx, field)
 906			case "interfaces":
 907				return ec.fieldContext___Type_interfaces(ctx, field)
 908			case "possibleTypes":
 909				return ec.fieldContext___Type_possibleTypes(ctx, field)
 910			case "enumValues":
 911				return ec.fieldContext___Type_enumValues(ctx, field)
 912			case "inputFields":
 913				return ec.fieldContext___Type_inputFields(ctx, field)
 914			case "ofType":
 915				return ec.fieldContext___Type_ofType(ctx, field)
 916			case "specifiedByURL":
 917				return ec.fieldContext___Type_specifiedByURL(ctx, field)
 918			}
 919			return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
 920		},
 921	}
 922	return fc, nil
 923}
 924
 925func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
 926	fc, err := ec.fieldContext___InputValue_defaultValue(ctx, field)
 927	if err != nil {
 928		return graphql.Null
 929	}
 930	ctx = graphql.WithFieldContext(ctx, fc)
 931	defer func() {
 932		if r := recover(); r != nil {
 933			ec.Error(ctx, ec.Recover(ctx, r))
 934			ret = graphql.Null
 935		}
 936	}()
 937	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 938		ctx = rctx // use context from middleware stack in children
 939		return obj.DefaultValue, nil
 940	})
 941	if err != nil {
 942		ec.Error(ctx, err)
 943		return graphql.Null
 944	}
 945	if resTmp == nil {
 946		return graphql.Null
 947	}
 948	res := resTmp.(*string)
 949	fc.Result = res
 950	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 951}
 952
 953func (ec *executionContext) fieldContext___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 954	fc = &graphql.FieldContext{
 955		Object:     "__InputValue",
 956		Field:      field,
 957		IsMethod:   false,
 958		IsResolver: false,
 959		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 960			return nil, errors.New("field of type String does not have child fields")
 961		},
 962	}
 963	return fc, nil
 964}
 965
 966func (ec *executionContext) ___Schema_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
 967	fc, err := ec.fieldContext___Schema_description(ctx, field)
 968	if err != nil {
 969		return graphql.Null
 970	}
 971	ctx = graphql.WithFieldContext(ctx, fc)
 972	defer func() {
 973		if r := recover(); r != nil {
 974			ec.Error(ctx, ec.Recover(ctx, r))
 975			ret = graphql.Null
 976		}
 977	}()
 978	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 979		ctx = rctx // use context from middleware stack in children
 980		return obj.Description(), nil
 981	})
 982	if err != nil {
 983		ec.Error(ctx, err)
 984		return graphql.Null
 985	}
 986	if resTmp == nil {
 987		return graphql.Null
 988	}
 989	res := resTmp.(*string)
 990	fc.Result = res
 991	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 992}
 993
 994func (ec *executionContext) fieldContext___Schema_description(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 995	fc = &graphql.FieldContext{
 996		Object:     "__Schema",
 997		Field:      field,
 998		IsMethod:   true,
 999		IsResolver: false,
1000		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1001			return nil, errors.New("field of type String does not have child fields")
1002		},
1003	}
1004	return fc, nil
1005}
1006
1007func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
1008	fc, err := ec.fieldContext___Schema_types(ctx, field)
1009	if err != nil {
1010		return graphql.Null
1011	}
1012	ctx = graphql.WithFieldContext(ctx, fc)
1013	defer func() {
1014		if r := recover(); r != nil {
1015			ec.Error(ctx, ec.Recover(ctx, r))
1016			ret = graphql.Null
1017		}
1018	}()
1019	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1020		ctx = rctx // use context from middleware stack in children
1021		return obj.Types(), nil
1022	})
1023	if err != nil {
1024		ec.Error(ctx, err)
1025		return graphql.Null
1026	}
1027	if resTmp == nil {
1028		if !graphql.HasFieldError(ctx, fc) {
1029			ec.Errorf(ctx, "must not be null")
1030		}
1031		return graphql.Null
1032	}
1033	res := resTmp.([]introspection.Type)
1034	fc.Result = res
1035	return ec.marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
1036}
1037
1038func (ec *executionContext) fieldContext___Schema_types(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1039	fc = &graphql.FieldContext{
1040		Object:     "__Schema",
1041		Field:      field,
1042		IsMethod:   true,
1043		IsResolver: false,
1044		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1045			switch field.Name {
1046			case "kind":
1047				return ec.fieldContext___Type_kind(ctx, field)
1048			case "name":
1049				return ec.fieldContext___Type_name(ctx, field)
1050			case "description":
1051				return ec.fieldContext___Type_description(ctx, field)
1052			case "fields":
1053				return ec.fieldContext___Type_fields(ctx, field)
1054			case "interfaces":
1055				return ec.fieldContext___Type_interfaces(ctx, field)
1056			case "possibleTypes":
1057				return ec.fieldContext___Type_possibleTypes(ctx, field)
1058			case "enumValues":
1059				return ec.fieldContext___Type_enumValues(ctx, field)
1060			case "inputFields":
1061				return ec.fieldContext___Type_inputFields(ctx, field)
1062			case "ofType":
1063				return ec.fieldContext___Type_ofType(ctx, field)
1064			case "specifiedByURL":
1065				return ec.fieldContext___Type_specifiedByURL(ctx, field)
1066			}
1067			return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
1068		},
1069	}
1070	return fc, nil
1071}
1072
1073func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
1074	fc, err := ec.fieldContext___Schema_queryType(ctx, field)
1075	if err != nil {
1076		return graphql.Null
1077	}
1078	ctx = graphql.WithFieldContext(ctx, fc)
1079	defer func() {
1080		if r := recover(); r != nil {
1081			ec.Error(ctx, ec.Recover(ctx, r))
1082			ret = graphql.Null
1083		}
1084	}()
1085	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1086		ctx = rctx // use context from middleware stack in children
1087		return obj.QueryType(), nil
1088	})
1089	if err != nil {
1090		ec.Error(ctx, err)
1091		return graphql.Null
1092	}
1093	if resTmp == nil {
1094		if !graphql.HasFieldError(ctx, fc) {
1095			ec.Errorf(ctx, "must not be null")
1096		}
1097		return graphql.Null
1098	}
1099	res := resTmp.(*introspection.Type)
1100	fc.Result = res
1101	return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
1102}
1103
1104func (ec *executionContext) fieldContext___Schema_queryType(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1105	fc = &graphql.FieldContext{
1106		Object:     "__Schema",
1107		Field:      field,
1108		IsMethod:   true,
1109		IsResolver: false,
1110		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1111			switch field.Name {
1112			case "kind":
1113				return ec.fieldContext___Type_kind(ctx, field)
1114			case "name":
1115				return ec.fieldContext___Type_name(ctx, field)
1116			case "description":
1117				return ec.fieldContext___Type_description(ctx, field)
1118			case "fields":
1119				return ec.fieldContext___Type_fields(ctx, field)
1120			case "interfaces":
1121				return ec.fieldContext___Type_interfaces(ctx, field)
1122			case "possibleTypes":
1123				return ec.fieldContext___Type_possibleTypes(ctx, field)
1124			case "enumValues":
1125				return ec.fieldContext___Type_enumValues(ctx, field)
1126			case "inputFields":
1127				return ec.fieldContext___Type_inputFields(ctx, field)
1128			case "ofType":
1129				return ec.fieldContext___Type_ofType(ctx, field)
1130			case "specifiedByURL":
1131				return ec.fieldContext___Type_specifiedByURL(ctx, field)
1132			}
1133			return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
1134		},
1135	}
1136	return fc, nil
1137}
1138
1139func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
1140	fc, err := ec.fieldContext___Schema_mutationType(ctx, field)
1141	if err != nil {
1142		return graphql.Null
1143	}
1144	ctx = graphql.WithFieldContext(ctx, fc)
1145	defer func() {
1146		if r := recover(); r != nil {
1147			ec.Error(ctx, ec.Recover(ctx, r))
1148			ret = graphql.Null
1149		}
1150	}()
1151	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1152		ctx = rctx // use context from middleware stack in children
1153		return obj.MutationType(), nil
1154	})
1155	if err != nil {
1156		ec.Error(ctx, err)
1157		return graphql.Null
1158	}
1159	if resTmp == nil {
1160		return graphql.Null
1161	}
1162	res := resTmp.(*introspection.Type)
1163	fc.Result = res
1164	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
1165}
1166
1167func (ec *executionContext) fieldContext___Schema_mutationType(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1168	fc = &graphql.FieldContext{
1169		Object:     "__Schema",
1170		Field:      field,
1171		IsMethod:   true,
1172		IsResolver: false,
1173		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1174			switch field.Name {
1175			case "kind":
1176				return ec.fieldContext___Type_kind(ctx, field)
1177			case "name":
1178				return ec.fieldContext___Type_name(ctx, field)
1179			case "description":
1180				return ec.fieldContext___Type_description(ctx, field)
1181			case "fields":
1182				return ec.fieldContext___Type_fields(ctx, field)
1183			case "interfaces":
1184				return ec.fieldContext___Type_interfaces(ctx, field)
1185			case "possibleTypes":
1186				return ec.fieldContext___Type_possibleTypes(ctx, field)
1187			case "enumValues":
1188				return ec.fieldContext___Type_enumValues(ctx, field)
1189			case "inputFields":
1190				return ec.fieldContext___Type_inputFields(ctx, field)
1191			case "ofType":
1192				return ec.fieldContext___Type_ofType(ctx, field)
1193			case "specifiedByURL":
1194				return ec.fieldContext___Type_specifiedByURL(ctx, field)
1195			}
1196			return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
1197		},
1198	}
1199	return fc, nil
1200}
1201
1202func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
1203	fc, err := ec.fieldContext___Schema_subscriptionType(ctx, field)
1204	if err != nil {
1205		return graphql.Null
1206	}
1207	ctx = graphql.WithFieldContext(ctx, fc)
1208	defer func() {
1209		if r := recover(); r != nil {
1210			ec.Error(ctx, ec.Recover(ctx, r))
1211			ret = graphql.Null
1212		}
1213	}()
1214	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1215		ctx = rctx // use context from middleware stack in children
1216		return obj.SubscriptionType(), nil
1217	})
1218	if err != nil {
1219		ec.Error(ctx, err)
1220		return graphql.Null
1221	}
1222	if resTmp == nil {
1223		return graphql.Null
1224	}
1225	res := resTmp.(*introspection.Type)
1226	fc.Result = res
1227	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
1228}
1229
1230func (ec *executionContext) fieldContext___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1231	fc = &graphql.FieldContext{
1232		Object:     "__Schema",
1233		Field:      field,
1234		IsMethod:   true,
1235		IsResolver: false,
1236		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1237			switch field.Name {
1238			case "kind":
1239				return ec.fieldContext___Type_kind(ctx, field)
1240			case "name":
1241				return ec.fieldContext___Type_name(ctx, field)
1242			case "description":
1243				return ec.fieldContext___Type_description(ctx, field)
1244			case "fields":
1245				return ec.fieldContext___Type_fields(ctx, field)
1246			case "interfaces":
1247				return ec.fieldContext___Type_interfaces(ctx, field)
1248			case "possibleTypes":
1249				return ec.fieldContext___Type_possibleTypes(ctx, field)
1250			case "enumValues":
1251				return ec.fieldContext___Type_enumValues(ctx, field)
1252			case "inputFields":
1253				return ec.fieldContext___Type_inputFields(ctx, field)
1254			case "ofType":
1255				return ec.fieldContext___Type_ofType(ctx, field)
1256			case "specifiedByURL":
1257				return ec.fieldContext___Type_specifiedByURL(ctx, field)
1258			}
1259			return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
1260		},
1261	}
1262	return fc, nil
1263}
1264
1265func (ec *executionContext) ___Schema_directives(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
1266	fc, err := ec.fieldContext___Schema_directives(ctx, field)
1267	if err != nil {
1268		return graphql.Null
1269	}
1270	ctx = graphql.WithFieldContext(ctx, fc)
1271	defer func() {
1272		if r := recover(); r != nil {
1273			ec.Error(ctx, ec.Recover(ctx, r))
1274			ret = graphql.Null
1275		}
1276	}()
1277	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1278		ctx = rctx // use context from middleware stack in children
1279		return obj.Directives(), nil
1280	})
1281	if err != nil {
1282		ec.Error(ctx, err)
1283		return graphql.Null
1284	}
1285	if resTmp == nil {
1286		if !graphql.HasFieldError(ctx, fc) {
1287			ec.Errorf(ctx, "must not be null")
1288		}
1289		return graphql.Null
1290	}
1291	res := resTmp.([]introspection.Directive)
1292	fc.Result = res
1293	return ec.marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx, field.Selections, res)
1294}
1295
1296func (ec *executionContext) fieldContext___Schema_directives(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1297	fc = &graphql.FieldContext{
1298		Object:     "__Schema",
1299		Field:      field,
1300		IsMethod:   true,
1301		IsResolver: false,
1302		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1303			switch field.Name {
1304			case "name":
1305				return ec.fieldContext___Directive_name(ctx, field)
1306			case "description":
1307				return ec.fieldContext___Directive_description(ctx, field)
1308			case "locations":
1309				return ec.fieldContext___Directive_locations(ctx, field)
1310			case "args":
1311				return ec.fieldContext___Directive_args(ctx, field)
1312			case "isRepeatable":
1313				return ec.fieldContext___Directive_isRepeatable(ctx, field)
1314			}
1315			return nil, fmt.Errorf("no field named %q was found under type __Directive", field.Name)
1316		},
1317	}
1318	return fc, nil
1319}
1320
1321func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
1322	fc, err := ec.fieldContext___Type_kind(ctx, field)
1323	if err != nil {
1324		return graphql.Null
1325	}
1326	ctx = graphql.WithFieldContext(ctx, fc)
1327	defer func() {
1328		if r := recover(); r != nil {
1329			ec.Error(ctx, ec.Recover(ctx, r))
1330			ret = graphql.Null
1331		}
1332	}()
1333	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1334		ctx = rctx // use context from middleware stack in children
1335		return obj.Kind(), nil
1336	})
1337	if err != nil {
1338		ec.Error(ctx, err)
1339		return graphql.Null
1340	}
1341	if resTmp == nil {
1342		if !graphql.HasFieldError(ctx, fc) {
1343			ec.Errorf(ctx, "must not be null")
1344		}
1345		return graphql.Null
1346	}
1347	res := resTmp.(string)
1348	fc.Result = res
1349	return ec.marshalN__TypeKind2string(ctx, field.Selections, res)
1350}
1351
1352func (ec *executionContext) fieldContext___Type_kind(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1353	fc = &graphql.FieldContext{
1354		Object:     "__Type",
1355		Field:      field,
1356		IsMethod:   true,
1357		IsResolver: false,
1358		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1359			return nil, errors.New("field of type __TypeKind does not have child fields")
1360		},
1361	}
1362	return fc, nil
1363}
1364
1365func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
1366	fc, err := ec.fieldContext___Type_name(ctx, field)
1367	if err != nil {
1368		return graphql.Null
1369	}
1370	ctx = graphql.WithFieldContext(ctx, fc)
1371	defer func() {
1372		if r := recover(); r != nil {
1373			ec.Error(ctx, ec.Recover(ctx, r))
1374			ret = graphql.Null
1375		}
1376	}()
1377	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1378		ctx = rctx // use context from middleware stack in children
1379		return obj.Name(), nil
1380	})
1381	if err != nil {
1382		ec.Error(ctx, err)
1383		return graphql.Null
1384	}
1385	if resTmp == nil {
1386		return graphql.Null
1387	}
1388	res := resTmp.(*string)
1389	fc.Result = res
1390	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
1391}
1392
1393func (ec *executionContext) fieldContext___Type_name(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1394	fc = &graphql.FieldContext{
1395		Object:     "__Type",
1396		Field:      field,
1397		IsMethod:   true,
1398		IsResolver: false,
1399		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1400			return nil, errors.New("field of type String does not have child fields")
1401		},
1402	}
1403	return fc, nil
1404}
1405
1406func (ec *executionContext) ___Type_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
1407	fc, err := ec.fieldContext___Type_description(ctx, field)
1408	if err != nil {
1409		return graphql.Null
1410	}
1411	ctx = graphql.WithFieldContext(ctx, fc)
1412	defer func() {
1413		if r := recover(); r != nil {
1414			ec.Error(ctx, ec.Recover(ctx, r))
1415			ret = graphql.Null
1416		}
1417	}()
1418	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1419		ctx = rctx // use context from middleware stack in children
1420		return obj.Description(), nil
1421	})
1422	if err != nil {
1423		ec.Error(ctx, err)
1424		return graphql.Null
1425	}
1426	if resTmp == nil {
1427		return graphql.Null
1428	}
1429	res := resTmp.(*string)
1430	fc.Result = res
1431	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
1432}
1433
1434func (ec *executionContext) fieldContext___Type_description(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1435	fc = &graphql.FieldContext{
1436		Object:     "__Type",
1437		Field:      field,
1438		IsMethod:   true,
1439		IsResolver: false,
1440		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1441			return nil, errors.New("field of type String does not have child fields")
1442		},
1443	}
1444	return fc, nil
1445}
1446
1447func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
1448	fc, err := ec.fieldContext___Type_fields(ctx, field)
1449	if err != nil {
1450		return graphql.Null
1451	}
1452	ctx = graphql.WithFieldContext(ctx, fc)
1453	defer func() {
1454		if r := recover(); r != nil {
1455			ec.Error(ctx, ec.Recover(ctx, r))
1456			ret = graphql.Null
1457		}
1458	}()
1459	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1460		ctx = rctx // use context from middleware stack in children
1461		return obj.Fields(fc.Args["includeDeprecated"].(bool)), nil
1462	})
1463	if err != nil {
1464		ec.Error(ctx, err)
1465		return graphql.Null
1466	}
1467	if resTmp == nil {
1468		return graphql.Null
1469	}
1470	res := resTmp.([]introspection.Field)
1471	fc.Result = res
1472	return ec.marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx, field.Selections, res)
1473}
1474
1475func (ec *executionContext) fieldContext___Type_fields(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1476	fc = &graphql.FieldContext{
1477		Object:     "__Type",
1478		Field:      field,
1479		IsMethod:   true,
1480		IsResolver: false,
1481		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1482			switch field.Name {
1483			case "name":
1484				return ec.fieldContext___Field_name(ctx, field)
1485			case "description":
1486				return ec.fieldContext___Field_description(ctx, field)
1487			case "args":
1488				return ec.fieldContext___Field_args(ctx, field)
1489			case "type":
1490				return ec.fieldContext___Field_type(ctx, field)
1491			case "isDeprecated":
1492				return ec.fieldContext___Field_isDeprecated(ctx, field)
1493			case "deprecationReason":
1494				return ec.fieldContext___Field_deprecationReason(ctx, field)
1495			}
1496			return nil, fmt.Errorf("no field named %q was found under type __Field", field.Name)
1497		},
1498	}
1499	defer func() {
1500		if r := recover(); r != nil {
1501			err = ec.Recover(ctx, r)
1502			ec.Error(ctx, err)
1503		}
1504	}()
1505	ctx = graphql.WithFieldContext(ctx, fc)
1506	if fc.Args, err = ec.field___Type_fields_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
1507		ec.Error(ctx, err)
1508		return fc, err
1509	}
1510	return fc, nil
1511}
1512
1513func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
1514	fc, err := ec.fieldContext___Type_interfaces(ctx, field)
1515	if err != nil {
1516		return graphql.Null
1517	}
1518	ctx = graphql.WithFieldContext(ctx, fc)
1519	defer func() {
1520		if r := recover(); r != nil {
1521			ec.Error(ctx, ec.Recover(ctx, r))
1522			ret = graphql.Null
1523		}
1524	}()
1525	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1526		ctx = rctx // use context from middleware stack in children
1527		return obj.Interfaces(), nil
1528	})
1529	if err != nil {
1530		ec.Error(ctx, err)
1531		return graphql.Null
1532	}
1533	if resTmp == nil {
1534		return graphql.Null
1535	}
1536	res := resTmp.([]introspection.Type)
1537	fc.Result = res
1538	return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
1539}
1540
1541func (ec *executionContext) fieldContext___Type_interfaces(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1542	fc = &graphql.FieldContext{
1543		Object:     "__Type",
1544		Field:      field,
1545		IsMethod:   true,
1546		IsResolver: false,
1547		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1548			switch field.Name {
1549			case "kind":
1550				return ec.fieldContext___Type_kind(ctx, field)
1551			case "name":
1552				return ec.fieldContext___Type_name(ctx, field)
1553			case "description":
1554				return ec.fieldContext___Type_description(ctx, field)
1555			case "fields":
1556				return ec.fieldContext___Type_fields(ctx, field)
1557			case "interfaces":
1558				return ec.fieldContext___Type_interfaces(ctx, field)
1559			case "possibleTypes":
1560				return ec.fieldContext___Type_possibleTypes(ctx, field)
1561			case "enumValues":
1562				return ec.fieldContext___Type_enumValues(ctx, field)
1563			case "inputFields":
1564				return ec.fieldContext___Type_inputFields(ctx, field)
1565			case "ofType":
1566				return ec.fieldContext___Type_ofType(ctx, field)
1567			case "specifiedByURL":
1568				return ec.fieldContext___Type_specifiedByURL(ctx, field)
1569			}
1570			return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
1571		},
1572	}
1573	return fc, nil
1574}
1575
1576func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
1577	fc, err := ec.fieldContext___Type_possibleTypes(ctx, field)
1578	if err != nil {
1579		return graphql.Null
1580	}
1581	ctx = graphql.WithFieldContext(ctx, fc)
1582	defer func() {
1583		if r := recover(); r != nil {
1584			ec.Error(ctx, ec.Recover(ctx, r))
1585			ret = graphql.Null
1586		}
1587	}()
1588	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1589		ctx = rctx // use context from middleware stack in children
1590		return obj.PossibleTypes(), nil
1591	})
1592	if err != nil {
1593		ec.Error(ctx, err)
1594		return graphql.Null
1595	}
1596	if resTmp == nil {
1597		return graphql.Null
1598	}
1599	res := resTmp.([]introspection.Type)
1600	fc.Result = res
1601	return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
1602}
1603
1604func (ec *executionContext) fieldContext___Type_possibleTypes(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1605	fc = &graphql.FieldContext{
1606		Object:     "__Type",
1607		Field:      field,
1608		IsMethod:   true,
1609		IsResolver: false,
1610		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1611			switch field.Name {
1612			case "kind":
1613				return ec.fieldContext___Type_kind(ctx, field)
1614			case "name":
1615				return ec.fieldContext___Type_name(ctx, field)
1616			case "description":
1617				return ec.fieldContext___Type_description(ctx, field)
1618			case "fields":
1619				return ec.fieldContext___Type_fields(ctx, field)
1620			case "interfaces":
1621				return ec.fieldContext___Type_interfaces(ctx, field)
1622			case "possibleTypes":
1623				return ec.fieldContext___Type_possibleTypes(ctx, field)
1624			case "enumValues":
1625				return ec.fieldContext___Type_enumValues(ctx, field)
1626			case "inputFields":
1627				return ec.fieldContext___Type_inputFields(ctx, field)
1628			case "ofType":
1629				return ec.fieldContext___Type_ofType(ctx, field)
1630			case "specifiedByURL":
1631				return ec.fieldContext___Type_specifiedByURL(ctx, field)
1632			}
1633			return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
1634		},
1635	}
1636	return fc, nil
1637}
1638
1639func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
1640	fc, err := ec.fieldContext___Type_enumValues(ctx, field)
1641	if err != nil {
1642		return graphql.Null
1643	}
1644	ctx = graphql.WithFieldContext(ctx, fc)
1645	defer func() {
1646		if r := recover(); r != nil {
1647			ec.Error(ctx, ec.Recover(ctx, r))
1648			ret = graphql.Null
1649		}
1650	}()
1651	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1652		ctx = rctx // use context from middleware stack in children
1653		return obj.EnumValues(fc.Args["includeDeprecated"].(bool)), nil
1654	})
1655	if err != nil {
1656		ec.Error(ctx, err)
1657		return graphql.Null
1658	}
1659	if resTmp == nil {
1660		return graphql.Null
1661	}
1662	res := resTmp.([]introspection.EnumValue)
1663	fc.Result = res
1664	return ec.marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx, field.Selections, res)
1665}
1666
1667func (ec *executionContext) fieldContext___Type_enumValues(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1668	fc = &graphql.FieldContext{
1669		Object:     "__Type",
1670		Field:      field,
1671		IsMethod:   true,
1672		IsResolver: false,
1673		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1674			switch field.Name {
1675			case "name":
1676				return ec.fieldContext___EnumValue_name(ctx, field)
1677			case "description":
1678				return ec.fieldContext___EnumValue_description(ctx, field)
1679			case "isDeprecated":
1680				return ec.fieldContext___EnumValue_isDeprecated(ctx, field)
1681			case "deprecationReason":
1682				return ec.fieldContext___EnumValue_deprecationReason(ctx, field)
1683			}
1684			return nil, fmt.Errorf("no field named %q was found under type __EnumValue", field.Name)
1685		},
1686	}
1687	defer func() {
1688		if r := recover(); r != nil {
1689			err = ec.Recover(ctx, r)
1690			ec.Error(ctx, err)
1691		}
1692	}()
1693	ctx = graphql.WithFieldContext(ctx, fc)
1694	if fc.Args, err = ec.field___Type_enumValues_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
1695		ec.Error(ctx, err)
1696		return fc, err
1697	}
1698	return fc, nil
1699}
1700
1701func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
1702	fc, err := ec.fieldContext___Type_inputFields(ctx, field)
1703	if err != nil {
1704		return graphql.Null
1705	}
1706	ctx = graphql.WithFieldContext(ctx, fc)
1707	defer func() {
1708		if r := recover(); r != nil {
1709			ec.Error(ctx, ec.Recover(ctx, r))
1710			ret = graphql.Null
1711		}
1712	}()
1713	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1714		ctx = rctx // use context from middleware stack in children
1715		return obj.InputFields(), nil
1716	})
1717	if err != nil {
1718		ec.Error(ctx, err)
1719		return graphql.Null
1720	}
1721	if resTmp == nil {
1722		return graphql.Null
1723	}
1724	res := resTmp.([]introspection.InputValue)
1725	fc.Result = res
1726	return ec.marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
1727}
1728
1729func (ec *executionContext) fieldContext___Type_inputFields(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1730	fc = &graphql.FieldContext{
1731		Object:     "__Type",
1732		Field:      field,
1733		IsMethod:   true,
1734		IsResolver: false,
1735		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1736			switch field.Name {
1737			case "name":
1738				return ec.fieldContext___InputValue_name(ctx, field)
1739			case "description":
1740				return ec.fieldContext___InputValue_description(ctx, field)
1741			case "type":
1742				return ec.fieldContext___InputValue_type(ctx, field)
1743			case "defaultValue":
1744				return ec.fieldContext___InputValue_defaultValue(ctx, field)
1745			}
1746			return nil, fmt.Errorf("no field named %q was found under type __InputValue", field.Name)
1747		},
1748	}
1749	return fc, nil
1750}
1751
1752func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
1753	fc, err := ec.fieldContext___Type_ofType(ctx, field)
1754	if err != nil {
1755		return graphql.Null
1756	}
1757	ctx = graphql.WithFieldContext(ctx, fc)
1758	defer func() {
1759		if r := recover(); r != nil {
1760			ec.Error(ctx, ec.Recover(ctx, r))
1761			ret = graphql.Null
1762		}
1763	}()
1764	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1765		ctx = rctx // use context from middleware stack in children
1766		return obj.OfType(), nil
1767	})
1768	if err != nil {
1769		ec.Error(ctx, err)
1770		return graphql.Null
1771	}
1772	if resTmp == nil {
1773		return graphql.Null
1774	}
1775	res := resTmp.(*introspection.Type)
1776	fc.Result = res
1777	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
1778}
1779
1780func (ec *executionContext) fieldContext___Type_ofType(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1781	fc = &graphql.FieldContext{
1782		Object:     "__Type",
1783		Field:      field,
1784		IsMethod:   true,
1785		IsResolver: false,
1786		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1787			switch field.Name {
1788			case "kind":
1789				return ec.fieldContext___Type_kind(ctx, field)
1790			case "name":
1791				return ec.fieldContext___Type_name(ctx, field)
1792			case "description":
1793				return ec.fieldContext___Type_description(ctx, field)
1794			case "fields":
1795				return ec.fieldContext___Type_fields(ctx, field)
1796			case "interfaces":
1797				return ec.fieldContext___Type_interfaces(ctx, field)
1798			case "possibleTypes":
1799				return ec.fieldContext___Type_possibleTypes(ctx, field)
1800			case "enumValues":
1801				return ec.fieldContext___Type_enumValues(ctx, field)
1802			case "inputFields":
1803				return ec.fieldContext___Type_inputFields(ctx, field)
1804			case "ofType":
1805				return ec.fieldContext___Type_ofType(ctx, field)
1806			case "specifiedByURL":
1807				return ec.fieldContext___Type_specifiedByURL(ctx, field)
1808			}
1809			return nil, fmt.Errorf("no field named %q was found under type __Type", field.Name)
1810		},
1811	}
1812	return fc, nil
1813}
1814
1815func (ec *executionContext) ___Type_specifiedByURL(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
1816	fc, err := ec.fieldContext___Type_specifiedByURL(ctx, field)
1817	if err != nil {
1818		return graphql.Null
1819	}
1820	ctx = graphql.WithFieldContext(ctx, fc)
1821	defer func() {
1822		if r := recover(); r != nil {
1823			ec.Error(ctx, ec.Recover(ctx, r))
1824			ret = graphql.Null
1825		}
1826	}()
1827	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
1828		ctx = rctx // use context from middleware stack in children
1829		return obj.SpecifiedByURL(), nil
1830	})
1831	if err != nil {
1832		ec.Error(ctx, err)
1833		return graphql.Null
1834	}
1835	if resTmp == nil {
1836		return graphql.Null
1837	}
1838	res := resTmp.(*string)
1839	fc.Result = res
1840	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
1841}
1842
1843func (ec *executionContext) fieldContext___Type_specifiedByURL(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1844	fc = &graphql.FieldContext{
1845		Object:     "__Type",
1846		Field:      field,
1847		IsMethod:   true,
1848		IsResolver: false,
1849		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1850			return nil, errors.New("field of type String does not have child fields")
1851		},
1852	}
1853	return fc, nil
1854}
1855
1856// endregion **************************** field.gotpl *****************************
1857
1858// region    **************************** input.gotpl *****************************
1859
1860// endregion **************************** input.gotpl *****************************
1861
1862// region    ************************** interface.gotpl ***************************
1863
1864// endregion ************************** interface.gotpl ***************************
1865
1866// region    **************************** object.gotpl ****************************
1867
1868var __DirectiveImplementors = []string{"__Directive"}
1869
1870func (ec *executionContext) ___Directive(ctx context.Context, sel ast.SelectionSet, obj *introspection.Directive) graphql.Marshaler {
1871	fields := graphql.CollectFields(ec.OperationContext, sel, __DirectiveImplementors)
1872
1873	out := graphql.NewFieldSet(fields)
1874	deferred := make(map[string]*graphql.FieldSet)
1875	for i, field := range fields {
1876		switch field.Name {
1877		case "__typename":
1878			out.Values[i] = graphql.MarshalString("__Directive")
1879		case "name":
1880			out.Values[i] = ec.___Directive_name(ctx, field, obj)
1881			if out.Values[i] == graphql.Null {
1882				out.Invalids++
1883			}
1884		case "description":
1885			out.Values[i] = ec.___Directive_description(ctx, field, obj)
1886		case "locations":
1887			out.Values[i] = ec.___Directive_locations(ctx, field, obj)
1888			if out.Values[i] == graphql.Null {
1889				out.Invalids++
1890			}
1891		case "args":
1892			out.Values[i] = ec.___Directive_args(ctx, field, obj)
1893			if out.Values[i] == graphql.Null {
1894				out.Invalids++
1895			}
1896		case "isRepeatable":
1897			out.Values[i] = ec.___Directive_isRepeatable(ctx, field, obj)
1898			if out.Values[i] == graphql.Null {
1899				out.Invalids++
1900			}
1901		default:
1902			panic("unknown field " + strconv.Quote(field.Name))
1903		}
1904	}
1905	out.Dispatch(ctx)
1906	if out.Invalids > 0 {
1907		return graphql.Null
1908	}
1909
1910	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
1911
1912	for label, dfs := range deferred {
1913		ec.processDeferredGroup(graphql.DeferredGroup{
1914			Label:    label,
1915			Path:     graphql.GetPath(ctx),
1916			FieldSet: dfs,
1917			Context:  ctx,
1918		})
1919	}
1920
1921	return out
1922}
1923
1924var __EnumValueImplementors = []string{"__EnumValue"}
1925
1926func (ec *executionContext) ___EnumValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.EnumValue) graphql.Marshaler {
1927	fields := graphql.CollectFields(ec.OperationContext, sel, __EnumValueImplementors)
1928
1929	out := graphql.NewFieldSet(fields)
1930	deferred := make(map[string]*graphql.FieldSet)
1931	for i, field := range fields {
1932		switch field.Name {
1933		case "__typename":
1934			out.Values[i] = graphql.MarshalString("__EnumValue")
1935		case "name":
1936			out.Values[i] = ec.___EnumValue_name(ctx, field, obj)
1937			if out.Values[i] == graphql.Null {
1938				out.Invalids++
1939			}
1940		case "description":
1941			out.Values[i] = ec.___EnumValue_description(ctx, field, obj)
1942		case "isDeprecated":
1943			out.Values[i] = ec.___EnumValue_isDeprecated(ctx, field, obj)
1944			if out.Values[i] == graphql.Null {
1945				out.Invalids++
1946			}
1947		case "deprecationReason":
1948			out.Values[i] = ec.___EnumValue_deprecationReason(ctx, field, obj)
1949		default:
1950			panic("unknown field " + strconv.Quote(field.Name))
1951		}
1952	}
1953	out.Dispatch(ctx)
1954	if out.Invalids > 0 {
1955		return graphql.Null
1956	}
1957
1958	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
1959
1960	for label, dfs := range deferred {
1961		ec.processDeferredGroup(graphql.DeferredGroup{
1962			Label:    label,
1963			Path:     graphql.GetPath(ctx),
1964			FieldSet: dfs,
1965			Context:  ctx,
1966		})
1967	}
1968
1969	return out
1970}
1971
1972var __FieldImplementors = []string{"__Field"}
1973
1974func (ec *executionContext) ___Field(ctx context.Context, sel ast.SelectionSet, obj *introspection.Field) graphql.Marshaler {
1975	fields := graphql.CollectFields(ec.OperationContext, sel, __FieldImplementors)
1976
1977	out := graphql.NewFieldSet(fields)
1978	deferred := make(map[string]*graphql.FieldSet)
1979	for i, field := range fields {
1980		switch field.Name {
1981		case "__typename":
1982			out.Values[i] = graphql.MarshalString("__Field")
1983		case "name":
1984			out.Values[i] = ec.___Field_name(ctx, field, obj)
1985			if out.Values[i] == graphql.Null {
1986				out.Invalids++
1987			}
1988		case "description":
1989			out.Values[i] = ec.___Field_description(ctx, field, obj)
1990		case "args":
1991			out.Values[i] = ec.___Field_args(ctx, field, obj)
1992			if out.Values[i] == graphql.Null {
1993				out.Invalids++
1994			}
1995		case "type":
1996			out.Values[i] = ec.___Field_type(ctx, field, obj)
1997			if out.Values[i] == graphql.Null {
1998				out.Invalids++
1999			}
2000		case "isDeprecated":
2001			out.Values[i] = ec.___Field_isDeprecated(ctx, field, obj)
2002			if out.Values[i] == graphql.Null {
2003				out.Invalids++
2004			}
2005		case "deprecationReason":
2006			out.Values[i] = ec.___Field_deprecationReason(ctx, field, obj)
2007		default:
2008			panic("unknown field " + strconv.Quote(field.Name))
2009		}
2010	}
2011	out.Dispatch(ctx)
2012	if out.Invalids > 0 {
2013		return graphql.Null
2014	}
2015
2016	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
2017
2018	for label, dfs := range deferred {
2019		ec.processDeferredGroup(graphql.DeferredGroup{
2020			Label:    label,
2021			Path:     graphql.GetPath(ctx),
2022			FieldSet: dfs,
2023			Context:  ctx,
2024		})
2025	}
2026
2027	return out
2028}
2029
2030var __InputValueImplementors = []string{"__InputValue"}
2031
2032func (ec *executionContext) ___InputValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.InputValue) graphql.Marshaler {
2033	fields := graphql.CollectFields(ec.OperationContext, sel, __InputValueImplementors)
2034
2035	out := graphql.NewFieldSet(fields)
2036	deferred := make(map[string]*graphql.FieldSet)
2037	for i, field := range fields {
2038		switch field.Name {
2039		case "__typename":
2040			out.Values[i] = graphql.MarshalString("__InputValue")
2041		case "name":
2042			out.Values[i] = ec.___InputValue_name(ctx, field, obj)
2043			if out.Values[i] == graphql.Null {
2044				out.Invalids++
2045			}
2046		case "description":
2047			out.Values[i] = ec.___InputValue_description(ctx, field, obj)
2048		case "type":
2049			out.Values[i] = ec.___InputValue_type(ctx, field, obj)
2050			if out.Values[i] == graphql.Null {
2051				out.Invalids++
2052			}
2053		case "defaultValue":
2054			out.Values[i] = ec.___InputValue_defaultValue(ctx, field, obj)
2055		default:
2056			panic("unknown field " + strconv.Quote(field.Name))
2057		}
2058	}
2059	out.Dispatch(ctx)
2060	if out.Invalids > 0 {
2061		return graphql.Null
2062	}
2063
2064	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
2065
2066	for label, dfs := range deferred {
2067		ec.processDeferredGroup(graphql.DeferredGroup{
2068			Label:    label,
2069			Path:     graphql.GetPath(ctx),
2070			FieldSet: dfs,
2071			Context:  ctx,
2072		})
2073	}
2074
2075	return out
2076}
2077
2078var __SchemaImplementors = []string{"__Schema"}
2079
2080func (ec *executionContext) ___Schema(ctx context.Context, sel ast.SelectionSet, obj *introspection.Schema) graphql.Marshaler {
2081	fields := graphql.CollectFields(ec.OperationContext, sel, __SchemaImplementors)
2082
2083	out := graphql.NewFieldSet(fields)
2084	deferred := make(map[string]*graphql.FieldSet)
2085	for i, field := range fields {
2086		switch field.Name {
2087		case "__typename":
2088			out.Values[i] = graphql.MarshalString("__Schema")
2089		case "description":
2090			out.Values[i] = ec.___Schema_description(ctx, field, obj)
2091		case "types":
2092			out.Values[i] = ec.___Schema_types(ctx, field, obj)
2093			if out.Values[i] == graphql.Null {
2094				out.Invalids++
2095			}
2096		case "queryType":
2097			out.Values[i] = ec.___Schema_queryType(ctx, field, obj)
2098			if out.Values[i] == graphql.Null {
2099				out.Invalids++
2100			}
2101		case "mutationType":
2102			out.Values[i] = ec.___Schema_mutationType(ctx, field, obj)
2103		case "subscriptionType":
2104			out.Values[i] = ec.___Schema_subscriptionType(ctx, field, obj)
2105		case "directives":
2106			out.Values[i] = ec.___Schema_directives(ctx, field, obj)
2107			if out.Values[i] == graphql.Null {
2108				out.Invalids++
2109			}
2110		default:
2111			panic("unknown field " + strconv.Quote(field.Name))
2112		}
2113	}
2114	out.Dispatch(ctx)
2115	if out.Invalids > 0 {
2116		return graphql.Null
2117	}
2118
2119	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
2120
2121	for label, dfs := range deferred {
2122		ec.processDeferredGroup(graphql.DeferredGroup{
2123			Label:    label,
2124			Path:     graphql.GetPath(ctx),
2125			FieldSet: dfs,
2126			Context:  ctx,
2127		})
2128	}
2129
2130	return out
2131}
2132
2133var __TypeImplementors = []string{"__Type"}
2134
2135func (ec *executionContext) ___Type(ctx context.Context, sel ast.SelectionSet, obj *introspection.Type) graphql.Marshaler {
2136	fields := graphql.CollectFields(ec.OperationContext, sel, __TypeImplementors)
2137
2138	out := graphql.NewFieldSet(fields)
2139	deferred := make(map[string]*graphql.FieldSet)
2140	for i, field := range fields {
2141		switch field.Name {
2142		case "__typename":
2143			out.Values[i] = graphql.MarshalString("__Type")
2144		case "kind":
2145			out.Values[i] = ec.___Type_kind(ctx, field, obj)
2146			if out.Values[i] == graphql.Null {
2147				out.Invalids++
2148			}
2149		case "name":
2150			out.Values[i] = ec.___Type_name(ctx, field, obj)
2151		case "description":
2152			out.Values[i] = ec.___Type_description(ctx, field, obj)
2153		case "fields":
2154			out.Values[i] = ec.___Type_fields(ctx, field, obj)
2155		case "interfaces":
2156			out.Values[i] = ec.___Type_interfaces(ctx, field, obj)
2157		case "possibleTypes":
2158			out.Values[i] = ec.___Type_possibleTypes(ctx, field, obj)
2159		case "enumValues":
2160			out.Values[i] = ec.___Type_enumValues(ctx, field, obj)
2161		case "inputFields":
2162			out.Values[i] = ec.___Type_inputFields(ctx, field, obj)
2163		case "ofType":
2164			out.Values[i] = ec.___Type_ofType(ctx, field, obj)
2165		case "specifiedByURL":
2166			out.Values[i] = ec.___Type_specifiedByURL(ctx, field, obj)
2167		default:
2168			panic("unknown field " + strconv.Quote(field.Name))
2169		}
2170	}
2171	out.Dispatch(ctx)
2172	if out.Invalids > 0 {
2173		return graphql.Null
2174	}
2175
2176	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
2177
2178	for label, dfs := range deferred {
2179		ec.processDeferredGroup(graphql.DeferredGroup{
2180			Label:    label,
2181			Path:     graphql.GetPath(ctx),
2182			FieldSet: dfs,
2183			Context:  ctx,
2184		})
2185	}
2186
2187	return out
2188}
2189
2190// endregion **************************** object.gotpl ****************************
2191
2192// region    ***************************** type.gotpl *****************************
2193
2194func (ec *executionContext) unmarshalNBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
2195	res, err := graphql.UnmarshalBoolean(v)
2196	return res, graphql.ErrorOnPath(ctx, err)
2197}
2198
2199func (ec *executionContext) marshalNBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
2200	res := graphql.MarshalBoolean(v)
2201	if res == graphql.Null {
2202		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
2203			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
2204		}
2205	}
2206	return res
2207}
2208
2209func (ec *executionContext) unmarshalNID2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋentityᚐId(ctx context.Context, v interface{}) (entity.Id, error) {
2210	var res entity.Id
2211	err := res.UnmarshalGQL(v)
2212	return res, graphql.ErrorOnPath(ctx, err)
2213}
2214
2215func (ec *executionContext) marshalNID2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋentityᚐId(ctx context.Context, sel ast.SelectionSet, v entity.Id) graphql.Marshaler {
2216	return v
2217}
2218
2219func (ec *executionContext) unmarshalNInt2int(ctx context.Context, v interface{}) (int, error) {
2220	res, err := graphql.UnmarshalInt(v)
2221	return res, graphql.ErrorOnPath(ctx, err)
2222}
2223
2224func (ec *executionContext) marshalNInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
2225	res := graphql.MarshalInt(v)
2226	if res == graphql.Null {
2227		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
2228			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
2229		}
2230	}
2231	return res
2232}
2233
2234func (ec *executionContext) unmarshalNString2string(ctx context.Context, v interface{}) (string, error) {
2235	res, err := graphql.UnmarshalString(v)
2236	return res, graphql.ErrorOnPath(ctx, err)
2237}
2238
2239func (ec *executionContext) marshalNString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
2240	res := graphql.MarshalString(v)
2241	if res == graphql.Null {
2242		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
2243			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
2244		}
2245	}
2246	return res
2247}
2248
2249func (ec *executionContext) marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx context.Context, sel ast.SelectionSet, v introspection.Directive) graphql.Marshaler {
2250	return ec.___Directive(ctx, sel, &v)
2251}
2252
2253func (ec *executionContext) marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Directive) graphql.Marshaler {
2254	ret := make(graphql.Array, len(v))
2255	var wg sync.WaitGroup
2256	isLen1 := len(v) == 1
2257	if !isLen1 {
2258		wg.Add(len(v))
2259	}
2260	for i := range v {
2261		i := i
2262		fc := &graphql.FieldContext{
2263			Index:  &i,
2264			Result: &v[i],
2265		}
2266		ctx := graphql.WithFieldContext(ctx, fc)
2267		f := func(i int) {
2268			defer func() {
2269				if r := recover(); r != nil {
2270					ec.Error(ctx, ec.Recover(ctx, r))
2271					ret = nil
2272				}
2273			}()
2274			if !isLen1 {
2275				defer wg.Done()
2276			}
2277			ret[i] = ec.marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx, sel, v[i])
2278		}
2279		if isLen1 {
2280			f(i)
2281		} else {
2282			go f(i)
2283		}
2284
2285	}
2286	wg.Wait()
2287
2288	for _, e := range ret {
2289		if e == graphql.Null {
2290			return graphql.Null
2291		}
2292	}
2293
2294	return ret
2295}
2296
2297func (ec *executionContext) unmarshalN__DirectiveLocation2string(ctx context.Context, v interface{}) (string, error) {
2298	res, err := graphql.UnmarshalString(v)
2299	return res, graphql.ErrorOnPath(ctx, err)
2300}
2301
2302func (ec *executionContext) marshalN__DirectiveLocation2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
2303	res := graphql.MarshalString(v)
2304	if res == graphql.Null {
2305		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
2306			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
2307		}
2308	}
2309	return res
2310}
2311
2312func (ec *executionContext) unmarshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
2313	var vSlice []interface{}
2314	if v != nil {
2315		vSlice = graphql.CoerceList(v)
2316	}
2317	var err error
2318	res := make([]string, len(vSlice))
2319	for i := range vSlice {
2320		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
2321		res[i], err = ec.unmarshalN__DirectiveLocation2string(ctx, vSlice[i])
2322		if err != nil {
2323			return nil, err
2324		}
2325	}
2326	return res, nil
2327}
2328
2329func (ec *executionContext) marshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
2330	ret := make(graphql.Array, len(v))
2331	var wg sync.WaitGroup
2332	isLen1 := len(v) == 1
2333	if !isLen1 {
2334		wg.Add(len(v))
2335	}
2336	for i := range v {
2337		i := i
2338		fc := &graphql.FieldContext{
2339			Index:  &i,
2340			Result: &v[i],
2341		}
2342		ctx := graphql.WithFieldContext(ctx, fc)
2343		f := func(i int) {
2344			defer func() {
2345				if r := recover(); r != nil {
2346					ec.Error(ctx, ec.Recover(ctx, r))
2347					ret = nil
2348				}
2349			}()
2350			if !isLen1 {
2351				defer wg.Done()
2352			}
2353			ret[i] = ec.marshalN__DirectiveLocation2string(ctx, sel, v[i])
2354		}
2355		if isLen1 {
2356			f(i)
2357		} else {
2358			go f(i)
2359		}
2360
2361	}
2362	wg.Wait()
2363
2364	for _, e := range ret {
2365		if e == graphql.Null {
2366			return graphql.Null
2367		}
2368	}
2369
2370	return ret
2371}
2372
2373func (ec *executionContext) marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx context.Context, sel ast.SelectionSet, v introspection.EnumValue) graphql.Marshaler {
2374	return ec.___EnumValue(ctx, sel, &v)
2375}
2376
2377func (ec *executionContext) marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx context.Context, sel ast.SelectionSet, v introspection.Field) graphql.Marshaler {
2378	return ec.___Field(ctx, sel, &v)
2379}
2380
2381func (ec *executionContext) marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx context.Context, sel ast.SelectionSet, v introspection.InputValue) graphql.Marshaler {
2382	return ec.___InputValue(ctx, sel, &v)
2383}
2384
2385func (ec *executionContext) marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
2386	ret := make(graphql.Array, len(v))
2387	var wg sync.WaitGroup
2388	isLen1 := len(v) == 1
2389	if !isLen1 {
2390		wg.Add(len(v))
2391	}
2392	for i := range v {
2393		i := i
2394		fc := &graphql.FieldContext{
2395			Index:  &i,
2396			Result: &v[i],
2397		}
2398		ctx := graphql.WithFieldContext(ctx, fc)
2399		f := func(i int) {
2400			defer func() {
2401				if r := recover(); r != nil {
2402					ec.Error(ctx, ec.Recover(ctx, r))
2403					ret = nil
2404				}
2405			}()
2406			if !isLen1 {
2407				defer wg.Done()
2408			}
2409			ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
2410		}
2411		if isLen1 {
2412			f(i)
2413		} else {
2414			go f(i)
2415		}
2416
2417	}
2418	wg.Wait()
2419
2420	for _, e := range ret {
2421		if e == graphql.Null {
2422			return graphql.Null
2423		}
2424	}
2425
2426	return ret
2427}
2428
2429func (ec *executionContext) marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v introspection.Type) graphql.Marshaler {
2430	return ec.___Type(ctx, sel, &v)
2431}
2432
2433func (ec *executionContext) marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
2434	ret := make(graphql.Array, len(v))
2435	var wg sync.WaitGroup
2436	isLen1 := len(v) == 1
2437	if !isLen1 {
2438		wg.Add(len(v))
2439	}
2440	for i := range v {
2441		i := i
2442		fc := &graphql.FieldContext{
2443			Index:  &i,
2444			Result: &v[i],
2445		}
2446		ctx := graphql.WithFieldContext(ctx, fc)
2447		f := func(i int) {
2448			defer func() {
2449				if r := recover(); r != nil {
2450					ec.Error(ctx, ec.Recover(ctx, r))
2451					ret = nil
2452				}
2453			}()
2454			if !isLen1 {
2455				defer wg.Done()
2456			}
2457			ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
2458		}
2459		if isLen1 {
2460			f(i)
2461		} else {
2462			go f(i)
2463		}
2464
2465	}
2466	wg.Wait()
2467
2468	for _, e := range ret {
2469		if e == graphql.Null {
2470			return graphql.Null
2471		}
2472	}
2473
2474	return ret
2475}
2476
2477func (ec *executionContext) marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
2478	if v == nil {
2479		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
2480			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
2481		}
2482		return graphql.Null
2483	}
2484	return ec.___Type(ctx, sel, v)
2485}
2486
2487func (ec *executionContext) unmarshalN__TypeKind2string(ctx context.Context, v interface{}) (string, error) {
2488	res, err := graphql.UnmarshalString(v)
2489	return res, graphql.ErrorOnPath(ctx, err)
2490}
2491
2492func (ec *executionContext) marshalN__TypeKind2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
2493	res := graphql.MarshalString(v)
2494	if res == graphql.Null {
2495		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
2496			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
2497		}
2498	}
2499	return res
2500}
2501
2502func (ec *executionContext) unmarshalOBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
2503	res, err := graphql.UnmarshalBoolean(v)
2504	return res, graphql.ErrorOnPath(ctx, err)
2505}
2506
2507func (ec *executionContext) marshalOBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
2508	res := graphql.MarshalBoolean(v)
2509	return res
2510}
2511
2512func (ec *executionContext) unmarshalOBoolean2ᚖbool(ctx context.Context, v interface{}) (*bool, error) {
2513	if v == nil {
2514		return nil, nil
2515	}
2516	res, err := graphql.UnmarshalBoolean(v)
2517	return &res, graphql.ErrorOnPath(ctx, err)
2518}
2519
2520func (ec *executionContext) marshalOBoolean2ᚖbool(ctx context.Context, sel ast.SelectionSet, v *bool) graphql.Marshaler {
2521	if v == nil {
2522		return graphql.Null
2523	}
2524	res := graphql.MarshalBoolean(*v)
2525	return res
2526}
2527
2528func (ec *executionContext) unmarshalOInt2ᚖint(ctx context.Context, v interface{}) (*int, error) {
2529	if v == nil {
2530		return nil, nil
2531	}
2532	res, err := graphql.UnmarshalInt(v)
2533	return &res, graphql.ErrorOnPath(ctx, err)
2534}
2535
2536func (ec *executionContext) marshalOInt2ᚖint(ctx context.Context, sel ast.SelectionSet, v *int) graphql.Marshaler {
2537	if v == nil {
2538		return graphql.Null
2539	}
2540	res := graphql.MarshalInt(*v)
2541	return res
2542}
2543
2544func (ec *executionContext) unmarshalOString2string(ctx context.Context, v interface{}) (string, error) {
2545	res, err := graphql.UnmarshalString(v)
2546	return res, graphql.ErrorOnPath(ctx, err)
2547}
2548
2549func (ec *executionContext) marshalOString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
2550	res := graphql.MarshalString(v)
2551	return res
2552}
2553
2554func (ec *executionContext) unmarshalOString2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
2555	if v == nil {
2556		return nil, nil
2557	}
2558	var vSlice []interface{}
2559	if v != nil {
2560		vSlice = graphql.CoerceList(v)
2561	}
2562	var err error
2563	res := make([]string, len(vSlice))
2564	for i := range vSlice {
2565		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
2566		res[i], err = ec.unmarshalNString2string(ctx, vSlice[i])
2567		if err != nil {
2568			return nil, err
2569		}
2570	}
2571	return res, nil
2572}
2573
2574func (ec *executionContext) marshalOString2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
2575	if v == nil {
2576		return graphql.Null
2577	}
2578	ret := make(graphql.Array, len(v))
2579	for i := range v {
2580		ret[i] = ec.marshalNString2string(ctx, sel, v[i])
2581	}
2582
2583	for _, e := range ret {
2584		if e == graphql.Null {
2585			return graphql.Null
2586		}
2587	}
2588
2589	return ret
2590}
2591
2592func (ec *executionContext) unmarshalOString2ᚖstring(ctx context.Context, v interface{}) (*string, error) {
2593	if v == nil {
2594		return nil, nil
2595	}
2596	res, err := graphql.UnmarshalString(v)
2597	return &res, graphql.ErrorOnPath(ctx, err)
2598}
2599
2600func (ec *executionContext) marshalOString2ᚖstring(ctx context.Context, sel ast.SelectionSet, v *string) graphql.Marshaler {
2601	if v == nil {
2602		return graphql.Null
2603	}
2604	res := graphql.MarshalString(*v)
2605	return res
2606}
2607
2608func (ec *executionContext) marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.EnumValue) graphql.Marshaler {
2609	if v == nil {
2610		return graphql.Null
2611	}
2612	ret := make(graphql.Array, len(v))
2613	var wg sync.WaitGroup
2614	isLen1 := len(v) == 1
2615	if !isLen1 {
2616		wg.Add(len(v))
2617	}
2618	for i := range v {
2619		i := i
2620		fc := &graphql.FieldContext{
2621			Index:  &i,
2622			Result: &v[i],
2623		}
2624		ctx := graphql.WithFieldContext(ctx, fc)
2625		f := func(i int) {
2626			defer func() {
2627				if r := recover(); r != nil {
2628					ec.Error(ctx, ec.Recover(ctx, r))
2629					ret = nil
2630				}
2631			}()
2632			if !isLen1 {
2633				defer wg.Done()
2634			}
2635			ret[i] = ec.marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx, sel, v[i])
2636		}
2637		if isLen1 {
2638			f(i)
2639		} else {
2640			go f(i)
2641		}
2642
2643	}
2644	wg.Wait()
2645
2646	for _, e := range ret {
2647		if e == graphql.Null {
2648			return graphql.Null
2649		}
2650	}
2651
2652	return ret
2653}
2654
2655func (ec *executionContext) marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Field) graphql.Marshaler {
2656	if v == nil {
2657		return graphql.Null
2658	}
2659	ret := make(graphql.Array, len(v))
2660	var wg sync.WaitGroup
2661	isLen1 := len(v) == 1
2662	if !isLen1 {
2663		wg.Add(len(v))
2664	}
2665	for i := range v {
2666		i := i
2667		fc := &graphql.FieldContext{
2668			Index:  &i,
2669			Result: &v[i],
2670		}
2671		ctx := graphql.WithFieldContext(ctx, fc)
2672		f := func(i int) {
2673			defer func() {
2674				if r := recover(); r != nil {
2675					ec.Error(ctx, ec.Recover(ctx, r))
2676					ret = nil
2677				}
2678			}()
2679			if !isLen1 {
2680				defer wg.Done()
2681			}
2682			ret[i] = ec.marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx, sel, v[i])
2683		}
2684		if isLen1 {
2685			f(i)
2686		} else {
2687			go f(i)
2688		}
2689
2690	}
2691	wg.Wait()
2692
2693	for _, e := range ret {
2694		if e == graphql.Null {
2695			return graphql.Null
2696		}
2697	}
2698
2699	return ret
2700}
2701
2702func (ec *executionContext) marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
2703	if v == nil {
2704		return graphql.Null
2705	}
2706	ret := make(graphql.Array, len(v))
2707	var wg sync.WaitGroup
2708	isLen1 := len(v) == 1
2709	if !isLen1 {
2710		wg.Add(len(v))
2711	}
2712	for i := range v {
2713		i := i
2714		fc := &graphql.FieldContext{
2715			Index:  &i,
2716			Result: &v[i],
2717		}
2718		ctx := graphql.WithFieldContext(ctx, fc)
2719		f := func(i int) {
2720			defer func() {
2721				if r := recover(); r != nil {
2722					ec.Error(ctx, ec.Recover(ctx, r))
2723					ret = nil
2724				}
2725			}()
2726			if !isLen1 {
2727				defer wg.Done()
2728			}
2729			ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
2730		}
2731		if isLen1 {
2732			f(i)
2733		} else {
2734			go f(i)
2735		}
2736
2737	}
2738	wg.Wait()
2739
2740	for _, e := range ret {
2741		if e == graphql.Null {
2742			return graphql.Null
2743		}
2744	}
2745
2746	return ret
2747}
2748
2749func (ec *executionContext) marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx context.Context, sel ast.SelectionSet, v *introspection.Schema) graphql.Marshaler {
2750	if v == nil {
2751		return graphql.Null
2752	}
2753	return ec.___Schema(ctx, sel, v)
2754}
2755
2756func (ec *executionContext) marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
2757	if v == nil {
2758		return graphql.Null
2759	}
2760	ret := make(graphql.Array, len(v))
2761	var wg sync.WaitGroup
2762	isLen1 := len(v) == 1
2763	if !isLen1 {
2764		wg.Add(len(v))
2765	}
2766	for i := range v {
2767		i := i
2768		fc := &graphql.FieldContext{
2769			Index:  &i,
2770			Result: &v[i],
2771		}
2772		ctx := graphql.WithFieldContext(ctx, fc)
2773		f := func(i int) {
2774			defer func() {
2775				if r := recover(); r != nil {
2776					ec.Error(ctx, ec.Recover(ctx, r))
2777					ret = nil
2778				}
2779			}()
2780			if !isLen1 {
2781				defer wg.Done()
2782			}
2783			ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
2784		}
2785		if isLen1 {
2786			f(i)
2787		} else {
2788			go f(i)
2789		}
2790
2791	}
2792	wg.Wait()
2793
2794	for _, e := range ret {
2795		if e == graphql.Null {
2796			return graphql.Null
2797		}
2798	}
2799
2800	return ret
2801}
2802
2803func (ec *executionContext) marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
2804	if v == nil {
2805		return graphql.Null
2806	}
2807	return ec.___Type(ctx, sel, v)
2808}
2809
2810// endregion ***************************** type.gotpl *****************************