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