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