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