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) marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx context.Context, sel ast.SelectionSet, v introspection.Directive) graphql.Marshaler {
2559	return ec.___Directive(ctx, sel, &v)
2560}
2561
2562func (ec *executionContext) marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Directive) graphql.Marshaler {
2563	ret := make(graphql.Array, len(v))
2564	var wg sync.WaitGroup
2565	isLen1 := len(v) == 1
2566	if !isLen1 {
2567		wg.Add(len(v))
2568	}
2569	for i := range v {
2570		i := i
2571		fc := &graphql.FieldContext{
2572			Index:  &i,
2573			Result: &v[i],
2574		}
2575		ctx := graphql.WithFieldContext(ctx, fc)
2576		f := func(i int) {
2577			defer func() {
2578				if r := recover(); r != nil {
2579					ec.Error(ctx, ec.Recover(ctx, r))
2580					ret = nil
2581				}
2582			}()
2583			if !isLen1 {
2584				defer wg.Done()
2585			}
2586			ret[i] = ec.marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx, sel, v[i])
2587		}
2588		if isLen1 {
2589			f(i)
2590		} else {
2591			go f(i)
2592		}
2593
2594	}
2595	wg.Wait()
2596
2597	for _, e := range ret {
2598		if e == graphql.Null {
2599			return graphql.Null
2600		}
2601	}
2602
2603	return ret
2604}
2605
2606func (ec *executionContext) unmarshalN__DirectiveLocation2string(ctx context.Context, v any) (string, error) {
2607	res, err := graphql.UnmarshalString(v)
2608	return res, graphql.ErrorOnPath(ctx, err)
2609}
2610
2611func (ec *executionContext) marshalN__DirectiveLocation2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
2612	_ = sel
2613	res := graphql.MarshalString(v)
2614	if res == graphql.Null {
2615		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
2616			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
2617		}
2618	}
2619	return res
2620}
2621
2622func (ec *executionContext) unmarshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, v any) ([]string, error) {
2623	var vSlice []any
2624	vSlice = graphql.CoerceList(v)
2625	var err error
2626	res := make([]string, len(vSlice))
2627	for i := range vSlice {
2628		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
2629		res[i], err = ec.unmarshalN__DirectiveLocation2string(ctx, vSlice[i])
2630		if err != nil {
2631			return nil, err
2632		}
2633	}
2634	return res, nil
2635}
2636
2637func (ec *executionContext) marshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
2638	ret := make(graphql.Array, len(v))
2639	var wg sync.WaitGroup
2640	isLen1 := len(v) == 1
2641	if !isLen1 {
2642		wg.Add(len(v))
2643	}
2644	for i := range v {
2645		i := i
2646		fc := &graphql.FieldContext{
2647			Index:  &i,
2648			Result: &v[i],
2649		}
2650		ctx := graphql.WithFieldContext(ctx, fc)
2651		f := func(i int) {
2652			defer func() {
2653				if r := recover(); r != nil {
2654					ec.Error(ctx, ec.Recover(ctx, r))
2655					ret = nil
2656				}
2657			}()
2658			if !isLen1 {
2659				defer wg.Done()
2660			}
2661			ret[i] = ec.marshalN__DirectiveLocation2string(ctx, sel, v[i])
2662		}
2663		if isLen1 {
2664			f(i)
2665		} else {
2666			go f(i)
2667		}
2668
2669	}
2670	wg.Wait()
2671
2672	for _, e := range ret {
2673		if e == graphql.Null {
2674			return graphql.Null
2675		}
2676	}
2677
2678	return ret
2679}
2680
2681func (ec *executionContext) marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx context.Context, sel ast.SelectionSet, v introspection.EnumValue) graphql.Marshaler {
2682	return ec.___EnumValue(ctx, sel, &v)
2683}
2684
2685func (ec *executionContext) marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx context.Context, sel ast.SelectionSet, v introspection.Field) graphql.Marshaler {
2686	return ec.___Field(ctx, sel, &v)
2687}
2688
2689func (ec *executionContext) marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx context.Context, sel ast.SelectionSet, v introspection.InputValue) graphql.Marshaler {
2690	return ec.___InputValue(ctx, sel, &v)
2691}
2692
2693func (ec *executionContext) marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
2694	ret := make(graphql.Array, len(v))
2695	var wg sync.WaitGroup
2696	isLen1 := len(v) == 1
2697	if !isLen1 {
2698		wg.Add(len(v))
2699	}
2700	for i := range v {
2701		i := i
2702		fc := &graphql.FieldContext{
2703			Index:  &i,
2704			Result: &v[i],
2705		}
2706		ctx := graphql.WithFieldContext(ctx, fc)
2707		f := func(i int) {
2708			defer func() {
2709				if r := recover(); r != nil {
2710					ec.Error(ctx, ec.Recover(ctx, r))
2711					ret = nil
2712				}
2713			}()
2714			if !isLen1 {
2715				defer wg.Done()
2716			}
2717			ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
2718		}
2719		if isLen1 {
2720			f(i)
2721		} else {
2722			go f(i)
2723		}
2724
2725	}
2726	wg.Wait()
2727
2728	for _, e := range ret {
2729		if e == graphql.Null {
2730			return graphql.Null
2731		}
2732	}
2733
2734	return ret
2735}
2736
2737func (ec *executionContext) marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v introspection.Type) graphql.Marshaler {
2738	return ec.___Type(ctx, sel, &v)
2739}
2740
2741func (ec *executionContext) marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
2742	ret := make(graphql.Array, len(v))
2743	var wg sync.WaitGroup
2744	isLen1 := len(v) == 1
2745	if !isLen1 {
2746		wg.Add(len(v))
2747	}
2748	for i := range v {
2749		i := i
2750		fc := &graphql.FieldContext{
2751			Index:  &i,
2752			Result: &v[i],
2753		}
2754		ctx := graphql.WithFieldContext(ctx, fc)
2755		f := func(i int) {
2756			defer func() {
2757				if r := recover(); r != nil {
2758					ec.Error(ctx, ec.Recover(ctx, r))
2759					ret = nil
2760				}
2761			}()
2762			if !isLen1 {
2763				defer wg.Done()
2764			}
2765			ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
2766		}
2767		if isLen1 {
2768			f(i)
2769		} else {
2770			go f(i)
2771		}
2772
2773	}
2774	wg.Wait()
2775
2776	for _, e := range ret {
2777		if e == graphql.Null {
2778			return graphql.Null
2779		}
2780	}
2781
2782	return ret
2783}
2784
2785func (ec *executionContext) marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
2786	if v == nil {
2787		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
2788			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
2789		}
2790		return graphql.Null
2791	}
2792	return ec.___Type(ctx, sel, v)
2793}
2794
2795func (ec *executionContext) unmarshalN__TypeKind2string(ctx context.Context, v any) (string, error) {
2796	res, err := graphql.UnmarshalString(v)
2797	return res, graphql.ErrorOnPath(ctx, err)
2798}
2799
2800func (ec *executionContext) marshalN__TypeKind2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
2801	_ = sel
2802	res := graphql.MarshalString(v)
2803	if res == graphql.Null {
2804		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
2805			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
2806		}
2807	}
2808	return res
2809}
2810
2811func (ec *executionContext) unmarshalOBoolean2bool(ctx context.Context, v any) (bool, error) {
2812	res, err := graphql.UnmarshalBoolean(v)
2813	return res, graphql.ErrorOnPath(ctx, err)
2814}
2815
2816func (ec *executionContext) marshalOBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
2817	_ = sel
2818	_ = ctx
2819	res := graphql.MarshalBoolean(v)
2820	return res
2821}
2822
2823func (ec *executionContext) unmarshalOBoolean2ᚖbool(ctx context.Context, v any) (*bool, error) {
2824	if v == nil {
2825		return nil, nil
2826	}
2827	res, err := graphql.UnmarshalBoolean(v)
2828	return &res, graphql.ErrorOnPath(ctx, err)
2829}
2830
2831func (ec *executionContext) marshalOBoolean2ᚖbool(ctx context.Context, sel ast.SelectionSet, v *bool) graphql.Marshaler {
2832	if v == nil {
2833		return graphql.Null
2834	}
2835	_ = sel
2836	_ = ctx
2837	res := graphql.MarshalBoolean(*v)
2838	return res
2839}
2840
2841func (ec *executionContext) unmarshalOInt2ᚖint(ctx context.Context, v any) (*int, error) {
2842	if v == nil {
2843		return nil, nil
2844	}
2845	res, err := graphql.UnmarshalInt(v)
2846	return &res, graphql.ErrorOnPath(ctx, err)
2847}
2848
2849func (ec *executionContext) marshalOInt2ᚖint(ctx context.Context, sel ast.SelectionSet, v *int) graphql.Marshaler {
2850	if v == nil {
2851		return graphql.Null
2852	}
2853	_ = sel
2854	_ = ctx
2855	res := graphql.MarshalInt(*v)
2856	return res
2857}
2858
2859func (ec *executionContext) unmarshalOString2string(ctx context.Context, v any) (string, error) {
2860	res, err := graphql.UnmarshalString(v)
2861	return res, graphql.ErrorOnPath(ctx, err)
2862}
2863
2864func (ec *executionContext) marshalOString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
2865	_ = sel
2866	_ = ctx
2867	res := graphql.MarshalString(v)
2868	return res
2869}
2870
2871func (ec *executionContext) unmarshalOString2ᚕstringᚄ(ctx context.Context, v any) ([]string, error) {
2872	if v == nil {
2873		return nil, nil
2874	}
2875	var vSlice []any
2876	vSlice = graphql.CoerceList(v)
2877	var err error
2878	res := make([]string, len(vSlice))
2879	for i := range vSlice {
2880		ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
2881		res[i], err = ec.unmarshalNString2string(ctx, vSlice[i])
2882		if err != nil {
2883			return nil, err
2884		}
2885	}
2886	return res, nil
2887}
2888
2889func (ec *executionContext) marshalOString2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
2890	if v == nil {
2891		return graphql.Null
2892	}
2893	ret := make(graphql.Array, len(v))
2894	for i := range v {
2895		ret[i] = ec.marshalNString2string(ctx, sel, v[i])
2896	}
2897
2898	for _, e := range ret {
2899		if e == graphql.Null {
2900			return graphql.Null
2901		}
2902	}
2903
2904	return ret
2905}
2906
2907func (ec *executionContext) unmarshalOString2ᚖstring(ctx context.Context, v any) (*string, error) {
2908	if v == nil {
2909		return nil, nil
2910	}
2911	res, err := graphql.UnmarshalString(v)
2912	return &res, graphql.ErrorOnPath(ctx, err)
2913}
2914
2915func (ec *executionContext) marshalOString2ᚖstring(ctx context.Context, sel ast.SelectionSet, v *string) graphql.Marshaler {
2916	if v == nil {
2917		return graphql.Null
2918	}
2919	_ = sel
2920	_ = ctx
2921	res := graphql.MarshalString(*v)
2922	return res
2923}
2924
2925func (ec *executionContext) marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.EnumValue) graphql.Marshaler {
2926	if v == nil {
2927		return graphql.Null
2928	}
2929	ret := make(graphql.Array, len(v))
2930	var wg sync.WaitGroup
2931	isLen1 := len(v) == 1
2932	if !isLen1 {
2933		wg.Add(len(v))
2934	}
2935	for i := range v {
2936		i := i
2937		fc := &graphql.FieldContext{
2938			Index:  &i,
2939			Result: &v[i],
2940		}
2941		ctx := graphql.WithFieldContext(ctx, fc)
2942		f := func(i int) {
2943			defer func() {
2944				if r := recover(); r != nil {
2945					ec.Error(ctx, ec.Recover(ctx, r))
2946					ret = nil
2947				}
2948			}()
2949			if !isLen1 {
2950				defer wg.Done()
2951			}
2952			ret[i] = ec.marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx, sel, v[i])
2953		}
2954		if isLen1 {
2955			f(i)
2956		} else {
2957			go f(i)
2958		}
2959
2960	}
2961	wg.Wait()
2962
2963	for _, e := range ret {
2964		if e == graphql.Null {
2965			return graphql.Null
2966		}
2967	}
2968
2969	return ret
2970}
2971
2972func (ec *executionContext) marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Field) graphql.Marshaler {
2973	if v == nil {
2974		return graphql.Null
2975	}
2976	ret := make(graphql.Array, len(v))
2977	var wg sync.WaitGroup
2978	isLen1 := len(v) == 1
2979	if !isLen1 {
2980		wg.Add(len(v))
2981	}
2982	for i := range v {
2983		i := i
2984		fc := &graphql.FieldContext{
2985			Index:  &i,
2986			Result: &v[i],
2987		}
2988		ctx := graphql.WithFieldContext(ctx, fc)
2989		f := func(i int) {
2990			defer func() {
2991				if r := recover(); r != nil {
2992					ec.Error(ctx, ec.Recover(ctx, r))
2993					ret = nil
2994				}
2995			}()
2996			if !isLen1 {
2997				defer wg.Done()
2998			}
2999			ret[i] = ec.marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx, sel, v[i])
3000		}
3001		if isLen1 {
3002			f(i)
3003		} else {
3004			go f(i)
3005		}
3006
3007	}
3008	wg.Wait()
3009
3010	for _, e := range ret {
3011		if e == graphql.Null {
3012			return graphql.Null
3013		}
3014	}
3015
3016	return ret
3017}
3018
3019func (ec *executionContext) marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
3020	if v == nil {
3021		return graphql.Null
3022	}
3023	ret := make(graphql.Array, len(v))
3024	var wg sync.WaitGroup
3025	isLen1 := len(v) == 1
3026	if !isLen1 {
3027		wg.Add(len(v))
3028	}
3029	for i := range v {
3030		i := i
3031		fc := &graphql.FieldContext{
3032			Index:  &i,
3033			Result: &v[i],
3034		}
3035		ctx := graphql.WithFieldContext(ctx, fc)
3036		f := func(i int) {
3037			defer func() {
3038				if r := recover(); r != nil {
3039					ec.Error(ctx, ec.Recover(ctx, r))
3040					ret = nil
3041				}
3042			}()
3043			if !isLen1 {
3044				defer wg.Done()
3045			}
3046			ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
3047		}
3048		if isLen1 {
3049			f(i)
3050		} else {
3051			go f(i)
3052		}
3053
3054	}
3055	wg.Wait()
3056
3057	for _, e := range ret {
3058		if e == graphql.Null {
3059			return graphql.Null
3060		}
3061	}
3062
3063	return ret
3064}
3065
3066func (ec *executionContext) marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx context.Context, sel ast.SelectionSet, v *introspection.Schema) graphql.Marshaler {
3067	if v == nil {
3068		return graphql.Null
3069	}
3070	return ec.___Schema(ctx, sel, v)
3071}
3072
3073func (ec *executionContext) marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
3074	if v == nil {
3075		return graphql.Null
3076	}
3077	ret := make(graphql.Array, len(v))
3078	var wg sync.WaitGroup
3079	isLen1 := len(v) == 1
3080	if !isLen1 {
3081		wg.Add(len(v))
3082	}
3083	for i := range v {
3084		i := i
3085		fc := &graphql.FieldContext{
3086			Index:  &i,
3087			Result: &v[i],
3088		}
3089		ctx := graphql.WithFieldContext(ctx, fc)
3090		f := func(i int) {
3091			defer func() {
3092				if r := recover(); r != nil {
3093					ec.Error(ctx, ec.Recover(ctx, r))
3094					ret = nil
3095				}
3096			}()
3097			if !isLen1 {
3098				defer wg.Done()
3099			}
3100			ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
3101		}
3102		if isLen1 {
3103			f(i)
3104		} else {
3105			go f(i)
3106		}
3107
3108	}
3109	wg.Wait()
3110
3111	for _, e := range ret {
3112		if e == graphql.Null {
3113			return graphql.Null
3114		}
3115	}
3116
3117	return ret
3118}
3119
3120func (ec *executionContext) marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
3121	if v == nil {
3122		return graphql.Null
3123	}
3124	return ec.___Type(ctx, sel, v)
3125}
3126
3127// endregion ***************************** type.gotpl *****************************