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	"time"
  13
  14	"github.com/99designs/gqlgen/graphql"
  15	"github.com/git-bug/git-bug/api/graphql/models"
  16	"github.com/git-bug/git-bug/entities/common"
  17	"github.com/git-bug/git-bug/entity"
  18	"github.com/vektah/gqlparser/v2/ast"
  19)
  20
  21// region    ************************** generated!.gotpl **************************
  22
  23type BugResolver interface {
  24	HumanID(ctx context.Context, obj models.BugWrapper) (string, error)
  25
  26	Actors(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
  27	Participants(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
  28	Comments(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.BugCommentConnection, error)
  29	Timeline(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.BugTimelineItemConnection, error)
  30	Operations(ctx context.Context, obj models.BugWrapper, after *string, before *string, first *int, last *int) (*models.OperationConnection, error)
  31}
  32
  33// endregion ************************** generated!.gotpl **************************
  34
  35// region    ***************************** args.gotpl *****************************
  36
  37func (ec *executionContext) field_Bug_actors_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
  38	var err error
  39	args := map[string]any{}
  40	arg0, err := ec.field_Bug_actors_argsAfter(ctx, rawArgs)
  41	if err != nil {
  42		return nil, err
  43	}
  44	args["after"] = arg0
  45	arg1, err := ec.field_Bug_actors_argsBefore(ctx, rawArgs)
  46	if err != nil {
  47		return nil, err
  48	}
  49	args["before"] = arg1
  50	arg2, err := ec.field_Bug_actors_argsFirst(ctx, rawArgs)
  51	if err != nil {
  52		return nil, err
  53	}
  54	args["first"] = arg2
  55	arg3, err := ec.field_Bug_actors_argsLast(ctx, rawArgs)
  56	if err != nil {
  57		return nil, err
  58	}
  59	args["last"] = arg3
  60	return args, nil
  61}
  62func (ec *executionContext) field_Bug_actors_argsAfter(
  63	ctx context.Context,
  64	rawArgs map[string]any,
  65) (*string, error) {
  66	if _, ok := rawArgs["after"]; !ok {
  67		var zeroVal *string
  68		return zeroVal, nil
  69	}
  70
  71	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("after"))
  72	if tmp, ok := rawArgs["after"]; ok {
  73		return ec.unmarshalOString2ᚖstring(ctx, tmp)
  74	}
  75
  76	var zeroVal *string
  77	return zeroVal, nil
  78}
  79
  80func (ec *executionContext) field_Bug_actors_argsBefore(
  81	ctx context.Context,
  82	rawArgs map[string]any,
  83) (*string, error) {
  84	if _, ok := rawArgs["before"]; !ok {
  85		var zeroVal *string
  86		return zeroVal, nil
  87	}
  88
  89	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("before"))
  90	if tmp, ok := rawArgs["before"]; ok {
  91		return ec.unmarshalOString2ᚖstring(ctx, tmp)
  92	}
  93
  94	var zeroVal *string
  95	return zeroVal, nil
  96}
  97
  98func (ec *executionContext) field_Bug_actors_argsFirst(
  99	ctx context.Context,
 100	rawArgs map[string]any,
 101) (*int, error) {
 102	if _, ok := rawArgs["first"]; !ok {
 103		var zeroVal *int
 104		return zeroVal, nil
 105	}
 106
 107	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("first"))
 108	if tmp, ok := rawArgs["first"]; ok {
 109		return ec.unmarshalOInt2ᚖint(ctx, tmp)
 110	}
 111
 112	var zeroVal *int
 113	return zeroVal, nil
 114}
 115
 116func (ec *executionContext) field_Bug_actors_argsLast(
 117	ctx context.Context,
 118	rawArgs map[string]any,
 119) (*int, error) {
 120	if _, ok := rawArgs["last"]; !ok {
 121		var zeroVal *int
 122		return zeroVal, nil
 123	}
 124
 125	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("last"))
 126	if tmp, ok := rawArgs["last"]; ok {
 127		return ec.unmarshalOInt2ᚖint(ctx, tmp)
 128	}
 129
 130	var zeroVal *int
 131	return zeroVal, nil
 132}
 133
 134func (ec *executionContext) field_Bug_comments_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
 135	var err error
 136	args := map[string]any{}
 137	arg0, err := ec.field_Bug_comments_argsAfter(ctx, rawArgs)
 138	if err != nil {
 139		return nil, err
 140	}
 141	args["after"] = arg0
 142	arg1, err := ec.field_Bug_comments_argsBefore(ctx, rawArgs)
 143	if err != nil {
 144		return nil, err
 145	}
 146	args["before"] = arg1
 147	arg2, err := ec.field_Bug_comments_argsFirst(ctx, rawArgs)
 148	if err != nil {
 149		return nil, err
 150	}
 151	args["first"] = arg2
 152	arg3, err := ec.field_Bug_comments_argsLast(ctx, rawArgs)
 153	if err != nil {
 154		return nil, err
 155	}
 156	args["last"] = arg3
 157	return args, nil
 158}
 159func (ec *executionContext) field_Bug_comments_argsAfter(
 160	ctx context.Context,
 161	rawArgs map[string]any,
 162) (*string, error) {
 163	if _, ok := rawArgs["after"]; !ok {
 164		var zeroVal *string
 165		return zeroVal, nil
 166	}
 167
 168	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("after"))
 169	if tmp, ok := rawArgs["after"]; ok {
 170		return ec.unmarshalOString2ᚖstring(ctx, tmp)
 171	}
 172
 173	var zeroVal *string
 174	return zeroVal, nil
 175}
 176
 177func (ec *executionContext) field_Bug_comments_argsBefore(
 178	ctx context.Context,
 179	rawArgs map[string]any,
 180) (*string, error) {
 181	if _, ok := rawArgs["before"]; !ok {
 182		var zeroVal *string
 183		return zeroVal, nil
 184	}
 185
 186	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("before"))
 187	if tmp, ok := rawArgs["before"]; ok {
 188		return ec.unmarshalOString2ᚖstring(ctx, tmp)
 189	}
 190
 191	var zeroVal *string
 192	return zeroVal, nil
 193}
 194
 195func (ec *executionContext) field_Bug_comments_argsFirst(
 196	ctx context.Context,
 197	rawArgs map[string]any,
 198) (*int, error) {
 199	if _, ok := rawArgs["first"]; !ok {
 200		var zeroVal *int
 201		return zeroVal, nil
 202	}
 203
 204	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("first"))
 205	if tmp, ok := rawArgs["first"]; ok {
 206		return ec.unmarshalOInt2ᚖint(ctx, tmp)
 207	}
 208
 209	var zeroVal *int
 210	return zeroVal, nil
 211}
 212
 213func (ec *executionContext) field_Bug_comments_argsLast(
 214	ctx context.Context,
 215	rawArgs map[string]any,
 216) (*int, error) {
 217	if _, ok := rawArgs["last"]; !ok {
 218		var zeroVal *int
 219		return zeroVal, nil
 220	}
 221
 222	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("last"))
 223	if tmp, ok := rawArgs["last"]; ok {
 224		return ec.unmarshalOInt2ᚖint(ctx, tmp)
 225	}
 226
 227	var zeroVal *int
 228	return zeroVal, nil
 229}
 230
 231func (ec *executionContext) field_Bug_operations_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
 232	var err error
 233	args := map[string]any{}
 234	arg0, err := ec.field_Bug_operations_argsAfter(ctx, rawArgs)
 235	if err != nil {
 236		return nil, err
 237	}
 238	args["after"] = arg0
 239	arg1, err := ec.field_Bug_operations_argsBefore(ctx, rawArgs)
 240	if err != nil {
 241		return nil, err
 242	}
 243	args["before"] = arg1
 244	arg2, err := ec.field_Bug_operations_argsFirst(ctx, rawArgs)
 245	if err != nil {
 246		return nil, err
 247	}
 248	args["first"] = arg2
 249	arg3, err := ec.field_Bug_operations_argsLast(ctx, rawArgs)
 250	if err != nil {
 251		return nil, err
 252	}
 253	args["last"] = arg3
 254	return args, nil
 255}
 256func (ec *executionContext) field_Bug_operations_argsAfter(
 257	ctx context.Context,
 258	rawArgs map[string]any,
 259) (*string, error) {
 260	if _, ok := rawArgs["after"]; !ok {
 261		var zeroVal *string
 262		return zeroVal, nil
 263	}
 264
 265	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("after"))
 266	if tmp, ok := rawArgs["after"]; ok {
 267		return ec.unmarshalOString2ᚖstring(ctx, tmp)
 268	}
 269
 270	var zeroVal *string
 271	return zeroVal, nil
 272}
 273
 274func (ec *executionContext) field_Bug_operations_argsBefore(
 275	ctx context.Context,
 276	rawArgs map[string]any,
 277) (*string, error) {
 278	if _, ok := rawArgs["before"]; !ok {
 279		var zeroVal *string
 280		return zeroVal, nil
 281	}
 282
 283	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("before"))
 284	if tmp, ok := rawArgs["before"]; ok {
 285		return ec.unmarshalOString2ᚖstring(ctx, tmp)
 286	}
 287
 288	var zeroVal *string
 289	return zeroVal, nil
 290}
 291
 292func (ec *executionContext) field_Bug_operations_argsFirst(
 293	ctx context.Context,
 294	rawArgs map[string]any,
 295) (*int, error) {
 296	if _, ok := rawArgs["first"]; !ok {
 297		var zeroVal *int
 298		return zeroVal, nil
 299	}
 300
 301	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("first"))
 302	if tmp, ok := rawArgs["first"]; ok {
 303		return ec.unmarshalOInt2ᚖint(ctx, tmp)
 304	}
 305
 306	var zeroVal *int
 307	return zeroVal, nil
 308}
 309
 310func (ec *executionContext) field_Bug_operations_argsLast(
 311	ctx context.Context,
 312	rawArgs map[string]any,
 313) (*int, error) {
 314	if _, ok := rawArgs["last"]; !ok {
 315		var zeroVal *int
 316		return zeroVal, nil
 317	}
 318
 319	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("last"))
 320	if tmp, ok := rawArgs["last"]; ok {
 321		return ec.unmarshalOInt2ᚖint(ctx, tmp)
 322	}
 323
 324	var zeroVal *int
 325	return zeroVal, nil
 326}
 327
 328func (ec *executionContext) field_Bug_participants_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
 329	var err error
 330	args := map[string]any{}
 331	arg0, err := ec.field_Bug_participants_argsAfter(ctx, rawArgs)
 332	if err != nil {
 333		return nil, err
 334	}
 335	args["after"] = arg0
 336	arg1, err := ec.field_Bug_participants_argsBefore(ctx, rawArgs)
 337	if err != nil {
 338		return nil, err
 339	}
 340	args["before"] = arg1
 341	arg2, err := ec.field_Bug_participants_argsFirst(ctx, rawArgs)
 342	if err != nil {
 343		return nil, err
 344	}
 345	args["first"] = arg2
 346	arg3, err := ec.field_Bug_participants_argsLast(ctx, rawArgs)
 347	if err != nil {
 348		return nil, err
 349	}
 350	args["last"] = arg3
 351	return args, nil
 352}
 353func (ec *executionContext) field_Bug_participants_argsAfter(
 354	ctx context.Context,
 355	rawArgs map[string]any,
 356) (*string, error) {
 357	if _, ok := rawArgs["after"]; !ok {
 358		var zeroVal *string
 359		return zeroVal, nil
 360	}
 361
 362	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("after"))
 363	if tmp, ok := rawArgs["after"]; ok {
 364		return ec.unmarshalOString2ᚖstring(ctx, tmp)
 365	}
 366
 367	var zeroVal *string
 368	return zeroVal, nil
 369}
 370
 371func (ec *executionContext) field_Bug_participants_argsBefore(
 372	ctx context.Context,
 373	rawArgs map[string]any,
 374) (*string, error) {
 375	if _, ok := rawArgs["before"]; !ok {
 376		var zeroVal *string
 377		return zeroVal, nil
 378	}
 379
 380	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("before"))
 381	if tmp, ok := rawArgs["before"]; ok {
 382		return ec.unmarshalOString2ᚖstring(ctx, tmp)
 383	}
 384
 385	var zeroVal *string
 386	return zeroVal, nil
 387}
 388
 389func (ec *executionContext) field_Bug_participants_argsFirst(
 390	ctx context.Context,
 391	rawArgs map[string]any,
 392) (*int, error) {
 393	if _, ok := rawArgs["first"]; !ok {
 394		var zeroVal *int
 395		return zeroVal, nil
 396	}
 397
 398	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("first"))
 399	if tmp, ok := rawArgs["first"]; ok {
 400		return ec.unmarshalOInt2ᚖint(ctx, tmp)
 401	}
 402
 403	var zeroVal *int
 404	return zeroVal, nil
 405}
 406
 407func (ec *executionContext) field_Bug_participants_argsLast(
 408	ctx context.Context,
 409	rawArgs map[string]any,
 410) (*int, error) {
 411	if _, ok := rawArgs["last"]; !ok {
 412		var zeroVal *int
 413		return zeroVal, nil
 414	}
 415
 416	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("last"))
 417	if tmp, ok := rawArgs["last"]; ok {
 418		return ec.unmarshalOInt2ᚖint(ctx, tmp)
 419	}
 420
 421	var zeroVal *int
 422	return zeroVal, nil
 423}
 424
 425func (ec *executionContext) field_Bug_timeline_args(ctx context.Context, rawArgs map[string]any) (map[string]any, error) {
 426	var err error
 427	args := map[string]any{}
 428	arg0, err := ec.field_Bug_timeline_argsAfter(ctx, rawArgs)
 429	if err != nil {
 430		return nil, err
 431	}
 432	args["after"] = arg0
 433	arg1, err := ec.field_Bug_timeline_argsBefore(ctx, rawArgs)
 434	if err != nil {
 435		return nil, err
 436	}
 437	args["before"] = arg1
 438	arg2, err := ec.field_Bug_timeline_argsFirst(ctx, rawArgs)
 439	if err != nil {
 440		return nil, err
 441	}
 442	args["first"] = arg2
 443	arg3, err := ec.field_Bug_timeline_argsLast(ctx, rawArgs)
 444	if err != nil {
 445		return nil, err
 446	}
 447	args["last"] = arg3
 448	return args, nil
 449}
 450func (ec *executionContext) field_Bug_timeline_argsAfter(
 451	ctx context.Context,
 452	rawArgs map[string]any,
 453) (*string, error) {
 454	if _, ok := rawArgs["after"]; !ok {
 455		var zeroVal *string
 456		return zeroVal, nil
 457	}
 458
 459	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("after"))
 460	if tmp, ok := rawArgs["after"]; ok {
 461		return ec.unmarshalOString2ᚖstring(ctx, tmp)
 462	}
 463
 464	var zeroVal *string
 465	return zeroVal, nil
 466}
 467
 468func (ec *executionContext) field_Bug_timeline_argsBefore(
 469	ctx context.Context,
 470	rawArgs map[string]any,
 471) (*string, error) {
 472	if _, ok := rawArgs["before"]; !ok {
 473		var zeroVal *string
 474		return zeroVal, nil
 475	}
 476
 477	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("before"))
 478	if tmp, ok := rawArgs["before"]; ok {
 479		return ec.unmarshalOString2ᚖstring(ctx, tmp)
 480	}
 481
 482	var zeroVal *string
 483	return zeroVal, nil
 484}
 485
 486func (ec *executionContext) field_Bug_timeline_argsFirst(
 487	ctx context.Context,
 488	rawArgs map[string]any,
 489) (*int, error) {
 490	if _, ok := rawArgs["first"]; !ok {
 491		var zeroVal *int
 492		return zeroVal, nil
 493	}
 494
 495	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("first"))
 496	if tmp, ok := rawArgs["first"]; ok {
 497		return ec.unmarshalOInt2ᚖint(ctx, tmp)
 498	}
 499
 500	var zeroVal *int
 501	return zeroVal, nil
 502}
 503
 504func (ec *executionContext) field_Bug_timeline_argsLast(
 505	ctx context.Context,
 506	rawArgs map[string]any,
 507) (*int, error) {
 508	if _, ok := rawArgs["last"]; !ok {
 509		var zeroVal *int
 510		return zeroVal, nil
 511	}
 512
 513	ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("last"))
 514	if tmp, ok := rawArgs["last"]; ok {
 515		return ec.unmarshalOInt2ᚖint(ctx, tmp)
 516	}
 517
 518	var zeroVal *int
 519	return zeroVal, nil
 520}
 521
 522// endregion ***************************** args.gotpl *****************************
 523
 524// region    ************************** directives.gotpl **************************
 525
 526// endregion ************************** directives.gotpl **************************
 527
 528// region    **************************** field.gotpl *****************************
 529
 530func (ec *executionContext) _Bug_id(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 531	fc, err := ec.fieldContext_Bug_id(ctx, field)
 532	if err != nil {
 533		return graphql.Null
 534	}
 535	ctx = graphql.WithFieldContext(ctx, fc)
 536	defer func() {
 537		if r := recover(); r != nil {
 538			ec.Error(ctx, ec.Recover(ctx, r))
 539			ret = graphql.Null
 540		}
 541	}()
 542	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
 543		ctx = rctx // use context from middleware stack in children
 544		return obj.Id(), nil
 545	})
 546	if err != nil {
 547		ec.Error(ctx, err)
 548		return graphql.Null
 549	}
 550	if resTmp == nil {
 551		if !graphql.HasFieldError(ctx, fc) {
 552			ec.Errorf(ctx, "must not be null")
 553		}
 554		return graphql.Null
 555	}
 556	res := resTmp.(entity.Id)
 557	fc.Result = res
 558	return ec.marshalNID2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentityᚐId(ctx, field.Selections, res)
 559}
 560
 561func (ec *executionContext) fieldContext_Bug_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 562	fc = &graphql.FieldContext{
 563		Object:     "Bug",
 564		Field:      field,
 565		IsMethod:   true,
 566		IsResolver: false,
 567		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 568			return nil, errors.New("field of type ID does not have child fields")
 569		},
 570	}
 571	return fc, nil
 572}
 573
 574func (ec *executionContext) _Bug_humanId(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 575	fc, err := ec.fieldContext_Bug_humanId(ctx, field)
 576	if err != nil {
 577		return graphql.Null
 578	}
 579	ctx = graphql.WithFieldContext(ctx, fc)
 580	defer func() {
 581		if r := recover(); r != nil {
 582			ec.Error(ctx, ec.Recover(ctx, r))
 583			ret = graphql.Null
 584		}
 585	}()
 586	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
 587		ctx = rctx // use context from middleware stack in children
 588		return ec.resolvers.Bug().HumanID(rctx, obj)
 589	})
 590	if err != nil {
 591		ec.Error(ctx, err)
 592		return graphql.Null
 593	}
 594	if resTmp == nil {
 595		if !graphql.HasFieldError(ctx, fc) {
 596			ec.Errorf(ctx, "must not be null")
 597		}
 598		return graphql.Null
 599	}
 600	res := resTmp.(string)
 601	fc.Result = res
 602	return ec.marshalNString2string(ctx, field.Selections, res)
 603}
 604
 605func (ec *executionContext) fieldContext_Bug_humanId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 606	fc = &graphql.FieldContext{
 607		Object:     "Bug",
 608		Field:      field,
 609		IsMethod:   true,
 610		IsResolver: true,
 611		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 612			return nil, errors.New("field of type String does not have child fields")
 613		},
 614	}
 615	return fc, nil
 616}
 617
 618func (ec *executionContext) _Bug_status(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 619	fc, err := ec.fieldContext_Bug_status(ctx, field)
 620	if err != nil {
 621		return graphql.Null
 622	}
 623	ctx = graphql.WithFieldContext(ctx, fc)
 624	defer func() {
 625		if r := recover(); r != nil {
 626			ec.Error(ctx, ec.Recover(ctx, r))
 627			ret = graphql.Null
 628		}
 629	}()
 630	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
 631		ctx = rctx // use context from middleware stack in children
 632		return obj.Status(), nil
 633	})
 634	if err != nil {
 635		ec.Error(ctx, err)
 636		return graphql.Null
 637	}
 638	if resTmp == nil {
 639		if !graphql.HasFieldError(ctx, fc) {
 640			ec.Errorf(ctx, "must not be null")
 641		}
 642		return graphql.Null
 643	}
 644	res := resTmp.(common.Status)
 645	fc.Result = res
 646	return ec.marshalNStatus2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋcommonᚐStatus(ctx, field.Selections, res)
 647}
 648
 649func (ec *executionContext) fieldContext_Bug_status(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 650	fc = &graphql.FieldContext{
 651		Object:     "Bug",
 652		Field:      field,
 653		IsMethod:   true,
 654		IsResolver: false,
 655		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 656			return nil, errors.New("field of type Status does not have child fields")
 657		},
 658	}
 659	return fc, nil
 660}
 661
 662func (ec *executionContext) _Bug_title(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 663	fc, err := ec.fieldContext_Bug_title(ctx, field)
 664	if err != nil {
 665		return graphql.Null
 666	}
 667	ctx = graphql.WithFieldContext(ctx, fc)
 668	defer func() {
 669		if r := recover(); r != nil {
 670			ec.Error(ctx, ec.Recover(ctx, r))
 671			ret = graphql.Null
 672		}
 673	}()
 674	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
 675		ctx = rctx // use context from middleware stack in children
 676		return obj.Title(), nil
 677	})
 678	if err != nil {
 679		ec.Error(ctx, err)
 680		return graphql.Null
 681	}
 682	if resTmp == nil {
 683		if !graphql.HasFieldError(ctx, fc) {
 684			ec.Errorf(ctx, "must not be null")
 685		}
 686		return graphql.Null
 687	}
 688	res := resTmp.(string)
 689	fc.Result = res
 690	return ec.marshalNString2string(ctx, field.Selections, res)
 691}
 692
 693func (ec *executionContext) fieldContext_Bug_title(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 694	fc = &graphql.FieldContext{
 695		Object:     "Bug",
 696		Field:      field,
 697		IsMethod:   true,
 698		IsResolver: false,
 699		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 700			return nil, errors.New("field of type String does not have child fields")
 701		},
 702	}
 703	return fc, nil
 704}
 705
 706func (ec *executionContext) _Bug_labels(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 707	fc, err := ec.fieldContext_Bug_labels(ctx, field)
 708	if err != nil {
 709		return graphql.Null
 710	}
 711	ctx = graphql.WithFieldContext(ctx, fc)
 712	defer func() {
 713		if r := recover(); r != nil {
 714			ec.Error(ctx, ec.Recover(ctx, r))
 715			ret = graphql.Null
 716		}
 717	}()
 718	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
 719		ctx = rctx // use context from middleware stack in children
 720		return obj.Labels(), nil
 721	})
 722	if err != nil {
 723		ec.Error(ctx, err)
 724		return graphql.Null
 725	}
 726	if resTmp == nil {
 727		if !graphql.HasFieldError(ctx, fc) {
 728			ec.Errorf(ctx, "must not be null")
 729		}
 730		return graphql.Null
 731	}
 732	res := resTmp.([]common.Label)
 733	fc.Result = res
 734	return ec.marshalNLabel2ᚕgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋcommonᚐLabelᚄ(ctx, field.Selections, res)
 735}
 736
 737func (ec *executionContext) fieldContext_Bug_labels(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 738	fc = &graphql.FieldContext{
 739		Object:     "Bug",
 740		Field:      field,
 741		IsMethod:   true,
 742		IsResolver: false,
 743		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 744			switch field.Name {
 745			case "name":
 746				return ec.fieldContext_Label_name(ctx, field)
 747			case "color":
 748				return ec.fieldContext_Label_color(ctx, field)
 749			}
 750			return nil, fmt.Errorf("no field named %q was found under type Label", field.Name)
 751		},
 752	}
 753	return fc, nil
 754}
 755
 756func (ec *executionContext) _Bug_author(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 757	fc, err := ec.fieldContext_Bug_author(ctx, field)
 758	if err != nil {
 759		return graphql.Null
 760	}
 761	ctx = graphql.WithFieldContext(ctx, fc)
 762	defer func() {
 763		if r := recover(); r != nil {
 764			ec.Error(ctx, ec.Recover(ctx, r))
 765			ret = graphql.Null
 766		}
 767	}()
 768	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
 769		ctx = rctx // use context from middleware stack in children
 770		return obj.Author()
 771	})
 772	if err != nil {
 773		ec.Error(ctx, err)
 774		return graphql.Null
 775	}
 776	if resTmp == nil {
 777		if !graphql.HasFieldError(ctx, fc) {
 778			ec.Errorf(ctx, "must not be null")
 779		}
 780		return graphql.Null
 781	}
 782	res := resTmp.(models.IdentityWrapper)
 783	fc.Result = res
 784	return ec.marshalNIdentity2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityWrapper(ctx, field.Selections, res)
 785}
 786
 787func (ec *executionContext) fieldContext_Bug_author(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 788	fc = &graphql.FieldContext{
 789		Object:     "Bug",
 790		Field:      field,
 791		IsMethod:   true,
 792		IsResolver: false,
 793		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 794			switch field.Name {
 795			case "id":
 796				return ec.fieldContext_Identity_id(ctx, field)
 797			case "humanId":
 798				return ec.fieldContext_Identity_humanId(ctx, field)
 799			case "name":
 800				return ec.fieldContext_Identity_name(ctx, field)
 801			case "email":
 802				return ec.fieldContext_Identity_email(ctx, field)
 803			case "login":
 804				return ec.fieldContext_Identity_login(ctx, field)
 805			case "displayName":
 806				return ec.fieldContext_Identity_displayName(ctx, field)
 807			case "avatarUrl":
 808				return ec.fieldContext_Identity_avatarUrl(ctx, field)
 809			case "isProtected":
 810				return ec.fieldContext_Identity_isProtected(ctx, field)
 811			}
 812			return nil, fmt.Errorf("no field named %q was found under type Identity", field.Name)
 813		},
 814	}
 815	return fc, nil
 816}
 817
 818func (ec *executionContext) _Bug_createdAt(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 819	fc, err := ec.fieldContext_Bug_createdAt(ctx, field)
 820	if err != nil {
 821		return graphql.Null
 822	}
 823	ctx = graphql.WithFieldContext(ctx, fc)
 824	defer func() {
 825		if r := recover(); r != nil {
 826			ec.Error(ctx, ec.Recover(ctx, r))
 827			ret = graphql.Null
 828		}
 829	}()
 830	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
 831		ctx = rctx // use context from middleware stack in children
 832		return obj.CreatedAt(), nil
 833	})
 834	if err != nil {
 835		ec.Error(ctx, err)
 836		return graphql.Null
 837	}
 838	if resTmp == nil {
 839		if !graphql.HasFieldError(ctx, fc) {
 840			ec.Errorf(ctx, "must not be null")
 841		}
 842		return graphql.Null
 843	}
 844	res := resTmp.(time.Time)
 845	fc.Result = res
 846	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
 847}
 848
 849func (ec *executionContext) fieldContext_Bug_createdAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 850	fc = &graphql.FieldContext{
 851		Object:     "Bug",
 852		Field:      field,
 853		IsMethod:   true,
 854		IsResolver: false,
 855		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 856			return nil, errors.New("field of type Time does not have child fields")
 857		},
 858	}
 859	return fc, nil
 860}
 861
 862func (ec *executionContext) _Bug_lastEdit(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 863	fc, err := ec.fieldContext_Bug_lastEdit(ctx, field)
 864	if err != nil {
 865		return graphql.Null
 866	}
 867	ctx = graphql.WithFieldContext(ctx, fc)
 868	defer func() {
 869		if r := recover(); r != nil {
 870			ec.Error(ctx, ec.Recover(ctx, r))
 871			ret = graphql.Null
 872		}
 873	}()
 874	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
 875		ctx = rctx // use context from middleware stack in children
 876		return obj.LastEdit(), nil
 877	})
 878	if err != nil {
 879		ec.Error(ctx, err)
 880		return graphql.Null
 881	}
 882	if resTmp == nil {
 883		if !graphql.HasFieldError(ctx, fc) {
 884			ec.Errorf(ctx, "must not be null")
 885		}
 886		return graphql.Null
 887	}
 888	res := resTmp.(time.Time)
 889	fc.Result = res
 890	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
 891}
 892
 893func (ec *executionContext) fieldContext_Bug_lastEdit(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 894	fc = &graphql.FieldContext{
 895		Object:     "Bug",
 896		Field:      field,
 897		IsMethod:   true,
 898		IsResolver: false,
 899		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 900			return nil, errors.New("field of type Time does not have child fields")
 901		},
 902	}
 903	return fc, nil
 904}
 905
 906func (ec *executionContext) _Bug_actors(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 907	fc, err := ec.fieldContext_Bug_actors(ctx, field)
 908	if err != nil {
 909		return graphql.Null
 910	}
 911	ctx = graphql.WithFieldContext(ctx, fc)
 912	defer func() {
 913		if r := recover(); r != nil {
 914			ec.Error(ctx, ec.Recover(ctx, r))
 915			ret = graphql.Null
 916		}
 917	}()
 918	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
 919		ctx = rctx // use context from middleware stack in children
 920		return ec.resolvers.Bug().Actors(rctx, obj, fc.Args["after"].(*string), fc.Args["before"].(*string), fc.Args["first"].(*int), fc.Args["last"].(*int))
 921	})
 922	if err != nil {
 923		ec.Error(ctx, err)
 924		return graphql.Null
 925	}
 926	if resTmp == nil {
 927		if !graphql.HasFieldError(ctx, fc) {
 928			ec.Errorf(ctx, "must not be null")
 929		}
 930		return graphql.Null
 931	}
 932	res := resTmp.(*models.IdentityConnection)
 933	fc.Result = res
 934	return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
 935}
 936
 937func (ec *executionContext) fieldContext_Bug_actors(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
 938	fc = &graphql.FieldContext{
 939		Object:     "Bug",
 940		Field:      field,
 941		IsMethod:   true,
 942		IsResolver: true,
 943		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
 944			switch field.Name {
 945			case "edges":
 946				return ec.fieldContext_IdentityConnection_edges(ctx, field)
 947			case "nodes":
 948				return ec.fieldContext_IdentityConnection_nodes(ctx, field)
 949			case "pageInfo":
 950				return ec.fieldContext_IdentityConnection_pageInfo(ctx, field)
 951			case "totalCount":
 952				return ec.fieldContext_IdentityConnection_totalCount(ctx, field)
 953			}
 954			return nil, fmt.Errorf("no field named %q was found under type IdentityConnection", field.Name)
 955		},
 956	}
 957	defer func() {
 958		if r := recover(); r != nil {
 959			err = ec.Recover(ctx, r)
 960			ec.Error(ctx, err)
 961		}
 962	}()
 963	ctx = graphql.WithFieldContext(ctx, fc)
 964	if fc.Args, err = ec.field_Bug_actors_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
 965		ec.Error(ctx, err)
 966		return fc, err
 967	}
 968	return fc, nil
 969}
 970
 971func (ec *executionContext) _Bug_participants(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
 972	fc, err := ec.fieldContext_Bug_participants(ctx, field)
 973	if err != nil {
 974		return graphql.Null
 975	}
 976	ctx = graphql.WithFieldContext(ctx, fc)
 977	defer func() {
 978		if r := recover(); r != nil {
 979			ec.Error(ctx, ec.Recover(ctx, r))
 980			ret = graphql.Null
 981		}
 982	}()
 983	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
 984		ctx = rctx // use context from middleware stack in children
 985		return ec.resolvers.Bug().Participants(rctx, obj, fc.Args["after"].(*string), fc.Args["before"].(*string), fc.Args["first"].(*int), fc.Args["last"].(*int))
 986	})
 987	if err != nil {
 988		ec.Error(ctx, err)
 989		return graphql.Null
 990	}
 991	if resTmp == nil {
 992		if !graphql.HasFieldError(ctx, fc) {
 993			ec.Errorf(ctx, "must not be null")
 994		}
 995		return graphql.Null
 996	}
 997	res := resTmp.(*models.IdentityConnection)
 998	fc.Result = res
 999	return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
1000}
1001
1002func (ec *executionContext) fieldContext_Bug_participants(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1003	fc = &graphql.FieldContext{
1004		Object:     "Bug",
1005		Field:      field,
1006		IsMethod:   true,
1007		IsResolver: true,
1008		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1009			switch field.Name {
1010			case "edges":
1011				return ec.fieldContext_IdentityConnection_edges(ctx, field)
1012			case "nodes":
1013				return ec.fieldContext_IdentityConnection_nodes(ctx, field)
1014			case "pageInfo":
1015				return ec.fieldContext_IdentityConnection_pageInfo(ctx, field)
1016			case "totalCount":
1017				return ec.fieldContext_IdentityConnection_totalCount(ctx, field)
1018			}
1019			return nil, fmt.Errorf("no field named %q was found under type IdentityConnection", field.Name)
1020		},
1021	}
1022	defer func() {
1023		if r := recover(); r != nil {
1024			err = ec.Recover(ctx, r)
1025			ec.Error(ctx, err)
1026		}
1027	}()
1028	ctx = graphql.WithFieldContext(ctx, fc)
1029	if fc.Args, err = ec.field_Bug_participants_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
1030		ec.Error(ctx, err)
1031		return fc, err
1032	}
1033	return fc, nil
1034}
1035
1036func (ec *executionContext) _Bug_comments(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
1037	fc, err := ec.fieldContext_Bug_comments(ctx, field)
1038	if err != nil {
1039		return graphql.Null
1040	}
1041	ctx = graphql.WithFieldContext(ctx, fc)
1042	defer func() {
1043		if r := recover(); r != nil {
1044			ec.Error(ctx, ec.Recover(ctx, r))
1045			ret = graphql.Null
1046		}
1047	}()
1048	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1049		ctx = rctx // use context from middleware stack in children
1050		return ec.resolvers.Bug().Comments(rctx, obj, fc.Args["after"].(*string), fc.Args["before"].(*string), fc.Args["first"].(*int), fc.Args["last"].(*int))
1051	})
1052	if err != nil {
1053		ec.Error(ctx, err)
1054		return graphql.Null
1055	}
1056	if resTmp == nil {
1057		if !graphql.HasFieldError(ctx, fc) {
1058			ec.Errorf(ctx, "must not be null")
1059		}
1060		return graphql.Null
1061	}
1062	res := resTmp.(*models.BugCommentConnection)
1063	fc.Result = res
1064	return ec.marshalNBugCommentConnection2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugCommentConnection(ctx, field.Selections, res)
1065}
1066
1067func (ec *executionContext) fieldContext_Bug_comments(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1068	fc = &graphql.FieldContext{
1069		Object:     "Bug",
1070		Field:      field,
1071		IsMethod:   true,
1072		IsResolver: true,
1073		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1074			switch field.Name {
1075			case "edges":
1076				return ec.fieldContext_BugCommentConnection_edges(ctx, field)
1077			case "nodes":
1078				return ec.fieldContext_BugCommentConnection_nodes(ctx, field)
1079			case "pageInfo":
1080				return ec.fieldContext_BugCommentConnection_pageInfo(ctx, field)
1081			case "totalCount":
1082				return ec.fieldContext_BugCommentConnection_totalCount(ctx, field)
1083			}
1084			return nil, fmt.Errorf("no field named %q was found under type BugCommentConnection", field.Name)
1085		},
1086	}
1087	defer func() {
1088		if r := recover(); r != nil {
1089			err = ec.Recover(ctx, r)
1090			ec.Error(ctx, err)
1091		}
1092	}()
1093	ctx = graphql.WithFieldContext(ctx, fc)
1094	if fc.Args, err = ec.field_Bug_comments_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
1095		ec.Error(ctx, err)
1096		return fc, err
1097	}
1098	return fc, nil
1099}
1100
1101func (ec *executionContext) _Bug_timeline(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
1102	fc, err := ec.fieldContext_Bug_timeline(ctx, field)
1103	if err != nil {
1104		return graphql.Null
1105	}
1106	ctx = graphql.WithFieldContext(ctx, fc)
1107	defer func() {
1108		if r := recover(); r != nil {
1109			ec.Error(ctx, ec.Recover(ctx, r))
1110			ret = graphql.Null
1111		}
1112	}()
1113	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1114		ctx = rctx // use context from middleware stack in children
1115		return ec.resolvers.Bug().Timeline(rctx, obj, fc.Args["after"].(*string), fc.Args["before"].(*string), fc.Args["first"].(*int), fc.Args["last"].(*int))
1116	})
1117	if err != nil {
1118		ec.Error(ctx, err)
1119		return graphql.Null
1120	}
1121	if resTmp == nil {
1122		if !graphql.HasFieldError(ctx, fc) {
1123			ec.Errorf(ctx, "must not be null")
1124		}
1125		return graphql.Null
1126	}
1127	res := resTmp.(*models.BugTimelineItemConnection)
1128	fc.Result = res
1129	return ec.marshalNBugTimelineItemConnection2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugTimelineItemConnection(ctx, field.Selections, res)
1130}
1131
1132func (ec *executionContext) fieldContext_Bug_timeline(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1133	fc = &graphql.FieldContext{
1134		Object:     "Bug",
1135		Field:      field,
1136		IsMethod:   true,
1137		IsResolver: true,
1138		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1139			switch field.Name {
1140			case "edges":
1141				return ec.fieldContext_BugTimelineItemConnection_edges(ctx, field)
1142			case "nodes":
1143				return ec.fieldContext_BugTimelineItemConnection_nodes(ctx, field)
1144			case "pageInfo":
1145				return ec.fieldContext_BugTimelineItemConnection_pageInfo(ctx, field)
1146			case "totalCount":
1147				return ec.fieldContext_BugTimelineItemConnection_totalCount(ctx, field)
1148			}
1149			return nil, fmt.Errorf("no field named %q was found under type BugTimelineItemConnection", field.Name)
1150		},
1151	}
1152	defer func() {
1153		if r := recover(); r != nil {
1154			err = ec.Recover(ctx, r)
1155			ec.Error(ctx, err)
1156		}
1157	}()
1158	ctx = graphql.WithFieldContext(ctx, fc)
1159	if fc.Args, err = ec.field_Bug_timeline_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
1160		ec.Error(ctx, err)
1161		return fc, err
1162	}
1163	return fc, nil
1164}
1165
1166func (ec *executionContext) _Bug_operations(ctx context.Context, field graphql.CollectedField, obj models.BugWrapper) (ret graphql.Marshaler) {
1167	fc, err := ec.fieldContext_Bug_operations(ctx, field)
1168	if err != nil {
1169		return graphql.Null
1170	}
1171	ctx = graphql.WithFieldContext(ctx, fc)
1172	defer func() {
1173		if r := recover(); r != nil {
1174			ec.Error(ctx, ec.Recover(ctx, r))
1175			ret = graphql.Null
1176		}
1177	}()
1178	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1179		ctx = rctx // use context from middleware stack in children
1180		return ec.resolvers.Bug().Operations(rctx, obj, fc.Args["after"].(*string), fc.Args["before"].(*string), fc.Args["first"].(*int), fc.Args["last"].(*int))
1181	})
1182	if err != nil {
1183		ec.Error(ctx, err)
1184		return graphql.Null
1185	}
1186	if resTmp == nil {
1187		if !graphql.HasFieldError(ctx, fc) {
1188			ec.Errorf(ctx, "must not be null")
1189		}
1190		return graphql.Null
1191	}
1192	res := resTmp.(*models.OperationConnection)
1193	fc.Result = res
1194	return ec.marshalNOperationConnection2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOperationConnection(ctx, field.Selections, res)
1195}
1196
1197func (ec *executionContext) fieldContext_Bug_operations(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1198	fc = &graphql.FieldContext{
1199		Object:     "Bug",
1200		Field:      field,
1201		IsMethod:   true,
1202		IsResolver: true,
1203		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1204			switch field.Name {
1205			case "edges":
1206				return ec.fieldContext_OperationConnection_edges(ctx, field)
1207			case "nodes":
1208				return ec.fieldContext_OperationConnection_nodes(ctx, field)
1209			case "pageInfo":
1210				return ec.fieldContext_OperationConnection_pageInfo(ctx, field)
1211			case "totalCount":
1212				return ec.fieldContext_OperationConnection_totalCount(ctx, field)
1213			}
1214			return nil, fmt.Errorf("no field named %q was found under type OperationConnection", field.Name)
1215		},
1216	}
1217	defer func() {
1218		if r := recover(); r != nil {
1219			err = ec.Recover(ctx, r)
1220			ec.Error(ctx, err)
1221		}
1222	}()
1223	ctx = graphql.WithFieldContext(ctx, fc)
1224	if fc.Args, err = ec.field_Bug_operations_args(ctx, field.ArgumentMap(ec.Variables)); err != nil {
1225		ec.Error(ctx, err)
1226		return fc, err
1227	}
1228	return fc, nil
1229}
1230
1231func (ec *executionContext) _BugConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
1232	fc, err := ec.fieldContext_BugConnection_edges(ctx, field)
1233	if err != nil {
1234		return graphql.Null
1235	}
1236	ctx = graphql.WithFieldContext(ctx, fc)
1237	defer func() {
1238		if r := recover(); r != nil {
1239			ec.Error(ctx, ec.Recover(ctx, r))
1240			ret = graphql.Null
1241		}
1242	}()
1243	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1244		ctx = rctx // use context from middleware stack in children
1245		return obj.Edges, nil
1246	})
1247	if err != nil {
1248		ec.Error(ctx, err)
1249		return graphql.Null
1250	}
1251	if resTmp == nil {
1252		if !graphql.HasFieldError(ctx, fc) {
1253			ec.Errorf(ctx, "must not be null")
1254		}
1255		return graphql.Null
1256	}
1257	res := resTmp.([]*models.BugEdge)
1258	fc.Result = res
1259	return ec.marshalNBugEdge2ᚕᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugEdgeᚄ(ctx, field.Selections, res)
1260}
1261
1262func (ec *executionContext) fieldContext_BugConnection_edges(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1263	fc = &graphql.FieldContext{
1264		Object:     "BugConnection",
1265		Field:      field,
1266		IsMethod:   false,
1267		IsResolver: false,
1268		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1269			switch field.Name {
1270			case "cursor":
1271				return ec.fieldContext_BugEdge_cursor(ctx, field)
1272			case "node":
1273				return ec.fieldContext_BugEdge_node(ctx, field)
1274			}
1275			return nil, fmt.Errorf("no field named %q was found under type BugEdge", field.Name)
1276		},
1277	}
1278	return fc, nil
1279}
1280
1281func (ec *executionContext) _BugConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
1282	fc, err := ec.fieldContext_BugConnection_nodes(ctx, field)
1283	if err != nil {
1284		return graphql.Null
1285	}
1286	ctx = graphql.WithFieldContext(ctx, fc)
1287	defer func() {
1288		if r := recover(); r != nil {
1289			ec.Error(ctx, ec.Recover(ctx, r))
1290			ret = graphql.Null
1291		}
1292	}()
1293	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1294		ctx = rctx // use context from middleware stack in children
1295		return obj.Nodes, nil
1296	})
1297	if err != nil {
1298		ec.Error(ctx, err)
1299		return graphql.Null
1300	}
1301	if resTmp == nil {
1302		if !graphql.HasFieldError(ctx, fc) {
1303			ec.Errorf(ctx, "must not be null")
1304		}
1305		return graphql.Null
1306	}
1307	res := resTmp.([]models.BugWrapper)
1308	fc.Result = res
1309	return ec.marshalNBug2ᚕgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapperᚄ(ctx, field.Selections, res)
1310}
1311
1312func (ec *executionContext) fieldContext_BugConnection_nodes(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1313	fc = &graphql.FieldContext{
1314		Object:     "BugConnection",
1315		Field:      field,
1316		IsMethod:   false,
1317		IsResolver: false,
1318		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1319			switch field.Name {
1320			case "id":
1321				return ec.fieldContext_Bug_id(ctx, field)
1322			case "humanId":
1323				return ec.fieldContext_Bug_humanId(ctx, field)
1324			case "status":
1325				return ec.fieldContext_Bug_status(ctx, field)
1326			case "title":
1327				return ec.fieldContext_Bug_title(ctx, field)
1328			case "labels":
1329				return ec.fieldContext_Bug_labels(ctx, field)
1330			case "author":
1331				return ec.fieldContext_Bug_author(ctx, field)
1332			case "createdAt":
1333				return ec.fieldContext_Bug_createdAt(ctx, field)
1334			case "lastEdit":
1335				return ec.fieldContext_Bug_lastEdit(ctx, field)
1336			case "actors":
1337				return ec.fieldContext_Bug_actors(ctx, field)
1338			case "participants":
1339				return ec.fieldContext_Bug_participants(ctx, field)
1340			case "comments":
1341				return ec.fieldContext_Bug_comments(ctx, field)
1342			case "timeline":
1343				return ec.fieldContext_Bug_timeline(ctx, field)
1344			case "operations":
1345				return ec.fieldContext_Bug_operations(ctx, field)
1346			}
1347			return nil, fmt.Errorf("no field named %q was found under type Bug", field.Name)
1348		},
1349	}
1350	return fc, nil
1351}
1352
1353func (ec *executionContext) _BugConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
1354	fc, err := ec.fieldContext_BugConnection_pageInfo(ctx, field)
1355	if err != nil {
1356		return graphql.Null
1357	}
1358	ctx = graphql.WithFieldContext(ctx, fc)
1359	defer func() {
1360		if r := recover(); r != nil {
1361			ec.Error(ctx, ec.Recover(ctx, r))
1362			ret = graphql.Null
1363		}
1364	}()
1365	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1366		ctx = rctx // use context from middleware stack in children
1367		return obj.PageInfo, nil
1368	})
1369	if err != nil {
1370		ec.Error(ctx, err)
1371		return graphql.Null
1372	}
1373	if resTmp == nil {
1374		if !graphql.HasFieldError(ctx, fc) {
1375			ec.Errorf(ctx, "must not be null")
1376		}
1377		return graphql.Null
1378	}
1379	res := resTmp.(*models.PageInfo)
1380	fc.Result = res
1381	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
1382}
1383
1384func (ec *executionContext) fieldContext_BugConnection_pageInfo(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1385	fc = &graphql.FieldContext{
1386		Object:     "BugConnection",
1387		Field:      field,
1388		IsMethod:   false,
1389		IsResolver: false,
1390		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1391			switch field.Name {
1392			case "hasNextPage":
1393				return ec.fieldContext_PageInfo_hasNextPage(ctx, field)
1394			case "hasPreviousPage":
1395				return ec.fieldContext_PageInfo_hasPreviousPage(ctx, field)
1396			case "startCursor":
1397				return ec.fieldContext_PageInfo_startCursor(ctx, field)
1398			case "endCursor":
1399				return ec.fieldContext_PageInfo_endCursor(ctx, field)
1400			}
1401			return nil, fmt.Errorf("no field named %q was found under type PageInfo", field.Name)
1402		},
1403	}
1404	return fc, nil
1405}
1406
1407func (ec *executionContext) _BugConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
1408	fc, err := ec.fieldContext_BugConnection_totalCount(ctx, field)
1409	if err != nil {
1410		return graphql.Null
1411	}
1412	ctx = graphql.WithFieldContext(ctx, fc)
1413	defer func() {
1414		if r := recover(); r != nil {
1415			ec.Error(ctx, ec.Recover(ctx, r))
1416			ret = graphql.Null
1417		}
1418	}()
1419	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1420		ctx = rctx // use context from middleware stack in children
1421		return obj.TotalCount, nil
1422	})
1423	if err != nil {
1424		ec.Error(ctx, err)
1425		return graphql.Null
1426	}
1427	if resTmp == nil {
1428		if !graphql.HasFieldError(ctx, fc) {
1429			ec.Errorf(ctx, "must not be null")
1430		}
1431		return graphql.Null
1432	}
1433	res := resTmp.(int)
1434	fc.Result = res
1435	return ec.marshalNInt2int(ctx, field.Selections, res)
1436}
1437
1438func (ec *executionContext) fieldContext_BugConnection_totalCount(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1439	fc = &graphql.FieldContext{
1440		Object:     "BugConnection",
1441		Field:      field,
1442		IsMethod:   false,
1443		IsResolver: false,
1444		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1445			return nil, errors.New("field of type Int does not have child fields")
1446		},
1447	}
1448	return fc, nil
1449}
1450
1451func (ec *executionContext) _BugEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.BugEdge) (ret graphql.Marshaler) {
1452	fc, err := ec.fieldContext_BugEdge_cursor(ctx, field)
1453	if err != nil {
1454		return graphql.Null
1455	}
1456	ctx = graphql.WithFieldContext(ctx, fc)
1457	defer func() {
1458		if r := recover(); r != nil {
1459			ec.Error(ctx, ec.Recover(ctx, r))
1460			ret = graphql.Null
1461		}
1462	}()
1463	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1464		ctx = rctx // use context from middleware stack in children
1465		return obj.Cursor, nil
1466	})
1467	if err != nil {
1468		ec.Error(ctx, err)
1469		return graphql.Null
1470	}
1471	if resTmp == nil {
1472		if !graphql.HasFieldError(ctx, fc) {
1473			ec.Errorf(ctx, "must not be null")
1474		}
1475		return graphql.Null
1476	}
1477	res := resTmp.(string)
1478	fc.Result = res
1479	return ec.marshalNString2string(ctx, field.Selections, res)
1480}
1481
1482func (ec *executionContext) fieldContext_BugEdge_cursor(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1483	fc = &graphql.FieldContext{
1484		Object:     "BugEdge",
1485		Field:      field,
1486		IsMethod:   false,
1487		IsResolver: false,
1488		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1489			return nil, errors.New("field of type String does not have child fields")
1490		},
1491	}
1492	return fc, nil
1493}
1494
1495func (ec *executionContext) _BugEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.BugEdge) (ret graphql.Marshaler) {
1496	fc, err := ec.fieldContext_BugEdge_node(ctx, field)
1497	if err != nil {
1498		return graphql.Null
1499	}
1500	ctx = graphql.WithFieldContext(ctx, fc)
1501	defer func() {
1502		if r := recover(); r != nil {
1503			ec.Error(ctx, ec.Recover(ctx, r))
1504			ret = graphql.Null
1505		}
1506	}()
1507	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
1508		ctx = rctx // use context from middleware stack in children
1509		return obj.Node, nil
1510	})
1511	if err != nil {
1512		ec.Error(ctx, err)
1513		return graphql.Null
1514	}
1515	if resTmp == nil {
1516		if !graphql.HasFieldError(ctx, fc) {
1517			ec.Errorf(ctx, "must not be null")
1518		}
1519		return graphql.Null
1520	}
1521	res := resTmp.(models.BugWrapper)
1522	fc.Result = res
1523	return ec.marshalNBug2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
1524}
1525
1526func (ec *executionContext) fieldContext_BugEdge_node(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
1527	fc = &graphql.FieldContext{
1528		Object:     "BugEdge",
1529		Field:      field,
1530		IsMethod:   false,
1531		IsResolver: false,
1532		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
1533			switch field.Name {
1534			case "id":
1535				return ec.fieldContext_Bug_id(ctx, field)
1536			case "humanId":
1537				return ec.fieldContext_Bug_humanId(ctx, field)
1538			case "status":
1539				return ec.fieldContext_Bug_status(ctx, field)
1540			case "title":
1541				return ec.fieldContext_Bug_title(ctx, field)
1542			case "labels":
1543				return ec.fieldContext_Bug_labels(ctx, field)
1544			case "author":
1545				return ec.fieldContext_Bug_author(ctx, field)
1546			case "createdAt":
1547				return ec.fieldContext_Bug_createdAt(ctx, field)
1548			case "lastEdit":
1549				return ec.fieldContext_Bug_lastEdit(ctx, field)
1550			case "actors":
1551				return ec.fieldContext_Bug_actors(ctx, field)
1552			case "participants":
1553				return ec.fieldContext_Bug_participants(ctx, field)
1554			case "comments":
1555				return ec.fieldContext_Bug_comments(ctx, field)
1556			case "timeline":
1557				return ec.fieldContext_Bug_timeline(ctx, field)
1558			case "operations":
1559				return ec.fieldContext_Bug_operations(ctx, field)
1560			}
1561			return nil, fmt.Errorf("no field named %q was found under type Bug", field.Name)
1562		},
1563	}
1564	return fc, nil
1565}
1566
1567// endregion **************************** field.gotpl *****************************
1568
1569// region    **************************** input.gotpl *****************************
1570
1571// endregion **************************** input.gotpl *****************************
1572
1573// region    ************************** interface.gotpl ***************************
1574
1575// endregion ************************** interface.gotpl ***************************
1576
1577// region    **************************** object.gotpl ****************************
1578
1579var bugImplementors = []string{"Bug", "Authored", "Entity"}
1580
1581func (ec *executionContext) _Bug(ctx context.Context, sel ast.SelectionSet, obj models.BugWrapper) graphql.Marshaler {
1582	fields := graphql.CollectFields(ec.OperationContext, sel, bugImplementors)
1583
1584	out := graphql.NewFieldSet(fields)
1585	deferred := make(map[string]*graphql.FieldSet)
1586	for i, field := range fields {
1587		switch field.Name {
1588		case "__typename":
1589			out.Values[i] = graphql.MarshalString("Bug")
1590		case "id":
1591			out.Values[i] = ec._Bug_id(ctx, field, obj)
1592			if out.Values[i] == graphql.Null {
1593				atomic.AddUint32(&out.Invalids, 1)
1594			}
1595		case "humanId":
1596			field := field
1597
1598			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
1599				defer func() {
1600					if r := recover(); r != nil {
1601						ec.Error(ctx, ec.Recover(ctx, r))
1602					}
1603				}()
1604				res = ec._Bug_humanId(ctx, field, obj)
1605				if res == graphql.Null {
1606					atomic.AddUint32(&fs.Invalids, 1)
1607				}
1608				return res
1609			}
1610
1611			if field.Deferrable != nil {
1612				dfs, ok := deferred[field.Deferrable.Label]
1613				di := 0
1614				if ok {
1615					dfs.AddField(field)
1616					di = len(dfs.Values) - 1
1617				} else {
1618					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
1619					deferred[field.Deferrable.Label] = dfs
1620				}
1621				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
1622					return innerFunc(ctx, dfs)
1623				})
1624
1625				// don't run the out.Concurrently() call below
1626				out.Values[i] = graphql.Null
1627				continue
1628			}
1629
1630			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
1631		case "status":
1632			out.Values[i] = ec._Bug_status(ctx, field, obj)
1633			if out.Values[i] == graphql.Null {
1634				atomic.AddUint32(&out.Invalids, 1)
1635			}
1636		case "title":
1637			out.Values[i] = ec._Bug_title(ctx, field, obj)
1638			if out.Values[i] == graphql.Null {
1639				atomic.AddUint32(&out.Invalids, 1)
1640			}
1641		case "labels":
1642			out.Values[i] = ec._Bug_labels(ctx, field, obj)
1643			if out.Values[i] == graphql.Null {
1644				atomic.AddUint32(&out.Invalids, 1)
1645			}
1646		case "author":
1647			out.Values[i] = ec._Bug_author(ctx, field, obj)
1648			if out.Values[i] == graphql.Null {
1649				atomic.AddUint32(&out.Invalids, 1)
1650			}
1651		case "createdAt":
1652			out.Values[i] = ec._Bug_createdAt(ctx, field, obj)
1653			if out.Values[i] == graphql.Null {
1654				atomic.AddUint32(&out.Invalids, 1)
1655			}
1656		case "lastEdit":
1657			out.Values[i] = ec._Bug_lastEdit(ctx, field, obj)
1658			if out.Values[i] == graphql.Null {
1659				atomic.AddUint32(&out.Invalids, 1)
1660			}
1661		case "actors":
1662			field := field
1663
1664			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
1665				defer func() {
1666					if r := recover(); r != nil {
1667						ec.Error(ctx, ec.Recover(ctx, r))
1668					}
1669				}()
1670				res = ec._Bug_actors(ctx, field, obj)
1671				if res == graphql.Null {
1672					atomic.AddUint32(&fs.Invalids, 1)
1673				}
1674				return res
1675			}
1676
1677			if field.Deferrable != nil {
1678				dfs, ok := deferred[field.Deferrable.Label]
1679				di := 0
1680				if ok {
1681					dfs.AddField(field)
1682					di = len(dfs.Values) - 1
1683				} else {
1684					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
1685					deferred[field.Deferrable.Label] = dfs
1686				}
1687				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
1688					return innerFunc(ctx, dfs)
1689				})
1690
1691				// don't run the out.Concurrently() call below
1692				out.Values[i] = graphql.Null
1693				continue
1694			}
1695
1696			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
1697		case "participants":
1698			field := field
1699
1700			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
1701				defer func() {
1702					if r := recover(); r != nil {
1703						ec.Error(ctx, ec.Recover(ctx, r))
1704					}
1705				}()
1706				res = ec._Bug_participants(ctx, field, obj)
1707				if res == graphql.Null {
1708					atomic.AddUint32(&fs.Invalids, 1)
1709				}
1710				return res
1711			}
1712
1713			if field.Deferrable != nil {
1714				dfs, ok := deferred[field.Deferrable.Label]
1715				di := 0
1716				if ok {
1717					dfs.AddField(field)
1718					di = len(dfs.Values) - 1
1719				} else {
1720					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
1721					deferred[field.Deferrable.Label] = dfs
1722				}
1723				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
1724					return innerFunc(ctx, dfs)
1725				})
1726
1727				// don't run the out.Concurrently() call below
1728				out.Values[i] = graphql.Null
1729				continue
1730			}
1731
1732			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
1733		case "comments":
1734			field := field
1735
1736			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
1737				defer func() {
1738					if r := recover(); r != nil {
1739						ec.Error(ctx, ec.Recover(ctx, r))
1740					}
1741				}()
1742				res = ec._Bug_comments(ctx, field, obj)
1743				if res == graphql.Null {
1744					atomic.AddUint32(&fs.Invalids, 1)
1745				}
1746				return res
1747			}
1748
1749			if field.Deferrable != nil {
1750				dfs, ok := deferred[field.Deferrable.Label]
1751				di := 0
1752				if ok {
1753					dfs.AddField(field)
1754					di = len(dfs.Values) - 1
1755				} else {
1756					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
1757					deferred[field.Deferrable.Label] = dfs
1758				}
1759				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
1760					return innerFunc(ctx, dfs)
1761				})
1762
1763				// don't run the out.Concurrently() call below
1764				out.Values[i] = graphql.Null
1765				continue
1766			}
1767
1768			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
1769		case "timeline":
1770			field := field
1771
1772			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
1773				defer func() {
1774					if r := recover(); r != nil {
1775						ec.Error(ctx, ec.Recover(ctx, r))
1776					}
1777				}()
1778				res = ec._Bug_timeline(ctx, field, obj)
1779				if res == graphql.Null {
1780					atomic.AddUint32(&fs.Invalids, 1)
1781				}
1782				return res
1783			}
1784
1785			if field.Deferrable != nil {
1786				dfs, ok := deferred[field.Deferrable.Label]
1787				di := 0
1788				if ok {
1789					dfs.AddField(field)
1790					di = len(dfs.Values) - 1
1791				} else {
1792					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
1793					deferred[field.Deferrable.Label] = dfs
1794				}
1795				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
1796					return innerFunc(ctx, dfs)
1797				})
1798
1799				// don't run the out.Concurrently() call below
1800				out.Values[i] = graphql.Null
1801				continue
1802			}
1803
1804			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
1805		case "operations":
1806			field := field
1807
1808			innerFunc := func(ctx context.Context, fs *graphql.FieldSet) (res graphql.Marshaler) {
1809				defer func() {
1810					if r := recover(); r != nil {
1811						ec.Error(ctx, ec.Recover(ctx, r))
1812					}
1813				}()
1814				res = ec._Bug_operations(ctx, field, obj)
1815				if res == graphql.Null {
1816					atomic.AddUint32(&fs.Invalids, 1)
1817				}
1818				return res
1819			}
1820
1821			if field.Deferrable != nil {
1822				dfs, ok := deferred[field.Deferrable.Label]
1823				di := 0
1824				if ok {
1825					dfs.AddField(field)
1826					di = len(dfs.Values) - 1
1827				} else {
1828					dfs = graphql.NewFieldSet([]graphql.CollectedField{field})
1829					deferred[field.Deferrable.Label] = dfs
1830				}
1831				dfs.Concurrently(di, func(ctx context.Context) graphql.Marshaler {
1832					return innerFunc(ctx, dfs)
1833				})
1834
1835				// don't run the out.Concurrently() call below
1836				out.Values[i] = graphql.Null
1837				continue
1838			}
1839
1840			out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) })
1841		default:
1842			panic("unknown field " + strconv.Quote(field.Name))
1843		}
1844	}
1845	out.Dispatch(ctx)
1846	if out.Invalids > 0 {
1847		return graphql.Null
1848	}
1849
1850	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
1851
1852	for label, dfs := range deferred {
1853		ec.processDeferredGroup(graphql.DeferredGroup{
1854			Label:    label,
1855			Path:     graphql.GetPath(ctx),
1856			FieldSet: dfs,
1857			Context:  ctx,
1858		})
1859	}
1860
1861	return out
1862}
1863
1864var bugConnectionImplementors = []string{"BugConnection"}
1865
1866func (ec *executionContext) _BugConnection(ctx context.Context, sel ast.SelectionSet, obj *models.BugConnection) graphql.Marshaler {
1867	fields := graphql.CollectFields(ec.OperationContext, sel, bugConnectionImplementors)
1868
1869	out := graphql.NewFieldSet(fields)
1870	deferred := make(map[string]*graphql.FieldSet)
1871	for i, field := range fields {
1872		switch field.Name {
1873		case "__typename":
1874			out.Values[i] = graphql.MarshalString("BugConnection")
1875		case "edges":
1876			out.Values[i] = ec._BugConnection_edges(ctx, field, obj)
1877			if out.Values[i] == graphql.Null {
1878				out.Invalids++
1879			}
1880		case "nodes":
1881			out.Values[i] = ec._BugConnection_nodes(ctx, field, obj)
1882			if out.Values[i] == graphql.Null {
1883				out.Invalids++
1884			}
1885		case "pageInfo":
1886			out.Values[i] = ec._BugConnection_pageInfo(ctx, field, obj)
1887			if out.Values[i] == graphql.Null {
1888				out.Invalids++
1889			}
1890		case "totalCount":
1891			out.Values[i] = ec._BugConnection_totalCount(ctx, field, obj)
1892			if out.Values[i] == graphql.Null {
1893				out.Invalids++
1894			}
1895		default:
1896			panic("unknown field " + strconv.Quote(field.Name))
1897		}
1898	}
1899	out.Dispatch(ctx)
1900	if out.Invalids > 0 {
1901		return graphql.Null
1902	}
1903
1904	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
1905
1906	for label, dfs := range deferred {
1907		ec.processDeferredGroup(graphql.DeferredGroup{
1908			Label:    label,
1909			Path:     graphql.GetPath(ctx),
1910			FieldSet: dfs,
1911			Context:  ctx,
1912		})
1913	}
1914
1915	return out
1916}
1917
1918var bugEdgeImplementors = []string{"BugEdge"}
1919
1920func (ec *executionContext) _BugEdge(ctx context.Context, sel ast.SelectionSet, obj *models.BugEdge) graphql.Marshaler {
1921	fields := graphql.CollectFields(ec.OperationContext, sel, bugEdgeImplementors)
1922
1923	out := graphql.NewFieldSet(fields)
1924	deferred := make(map[string]*graphql.FieldSet)
1925	for i, field := range fields {
1926		switch field.Name {
1927		case "__typename":
1928			out.Values[i] = graphql.MarshalString("BugEdge")
1929		case "cursor":
1930			out.Values[i] = ec._BugEdge_cursor(ctx, field, obj)
1931			if out.Values[i] == graphql.Null {
1932				out.Invalids++
1933			}
1934		case "node":
1935			out.Values[i] = ec._BugEdge_node(ctx, field, obj)
1936			if out.Values[i] == graphql.Null {
1937				out.Invalids++
1938			}
1939		default:
1940			panic("unknown field " + strconv.Quote(field.Name))
1941		}
1942	}
1943	out.Dispatch(ctx)
1944	if out.Invalids > 0 {
1945		return graphql.Null
1946	}
1947
1948	atomic.AddInt32(&ec.deferred, int32(len(deferred)))
1949
1950	for label, dfs := range deferred {
1951		ec.processDeferredGroup(graphql.DeferredGroup{
1952			Label:    label,
1953			Path:     graphql.GetPath(ctx),
1954			FieldSet: dfs,
1955			Context:  ctx,
1956		})
1957	}
1958
1959	return out
1960}
1961
1962// endregion **************************** object.gotpl ****************************
1963
1964// region    ***************************** type.gotpl *****************************
1965
1966func (ec *executionContext) marshalNBug2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx context.Context, sel ast.SelectionSet, v models.BugWrapper) graphql.Marshaler {
1967	if v == nil {
1968		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
1969			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
1970		}
1971		return graphql.Null
1972	}
1973	return ec._Bug(ctx, sel, v)
1974}
1975
1976func (ec *executionContext) marshalNBug2ᚕgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapperᚄ(ctx context.Context, sel ast.SelectionSet, v []models.BugWrapper) graphql.Marshaler {
1977	ret := make(graphql.Array, len(v))
1978	var wg sync.WaitGroup
1979	isLen1 := len(v) == 1
1980	if !isLen1 {
1981		wg.Add(len(v))
1982	}
1983	for i := range v {
1984		i := i
1985		fc := &graphql.FieldContext{
1986			Index:  &i,
1987			Result: &v[i],
1988		}
1989		ctx := graphql.WithFieldContext(ctx, fc)
1990		f := func(i int) {
1991			defer func() {
1992				if r := recover(); r != nil {
1993					ec.Error(ctx, ec.Recover(ctx, r))
1994					ret = nil
1995				}
1996			}()
1997			if !isLen1 {
1998				defer wg.Done()
1999			}
2000			ret[i] = ec.marshalNBug2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, sel, v[i])
2001		}
2002		if isLen1 {
2003			f(i)
2004		} else {
2005			go f(i)
2006		}
2007
2008	}
2009	wg.Wait()
2010
2011	for _, e := range ret {
2012		if e == graphql.Null {
2013			return graphql.Null
2014		}
2015	}
2016
2017	return ret
2018}
2019
2020func (ec *executionContext) marshalNBugConnection2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugConnection(ctx context.Context, sel ast.SelectionSet, v models.BugConnection) graphql.Marshaler {
2021	return ec._BugConnection(ctx, sel, &v)
2022}
2023
2024func (ec *executionContext) marshalNBugConnection2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugConnection(ctx context.Context, sel ast.SelectionSet, v *models.BugConnection) graphql.Marshaler {
2025	if v == nil {
2026		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
2027			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
2028		}
2029		return graphql.Null
2030	}
2031	return ec._BugConnection(ctx, sel, v)
2032}
2033
2034func (ec *executionContext) marshalNBugEdge2ᚕᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugEdgeᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.BugEdge) graphql.Marshaler {
2035	ret := make(graphql.Array, len(v))
2036	var wg sync.WaitGroup
2037	isLen1 := len(v) == 1
2038	if !isLen1 {
2039		wg.Add(len(v))
2040	}
2041	for i := range v {
2042		i := i
2043		fc := &graphql.FieldContext{
2044			Index:  &i,
2045			Result: &v[i],
2046		}
2047		ctx := graphql.WithFieldContext(ctx, fc)
2048		f := func(i int) {
2049			defer func() {
2050				if r := recover(); r != nil {
2051					ec.Error(ctx, ec.Recover(ctx, r))
2052					ret = nil
2053				}
2054			}()
2055			if !isLen1 {
2056				defer wg.Done()
2057			}
2058			ret[i] = ec.marshalNBugEdge2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugEdge(ctx, sel, v[i])
2059		}
2060		if isLen1 {
2061			f(i)
2062		} else {
2063			go f(i)
2064		}
2065
2066	}
2067	wg.Wait()
2068
2069	for _, e := range ret {
2070		if e == graphql.Null {
2071			return graphql.Null
2072		}
2073	}
2074
2075	return ret
2076}
2077
2078func (ec *executionContext) marshalNBugEdge2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugEdge(ctx context.Context, sel ast.SelectionSet, v *models.BugEdge) graphql.Marshaler {
2079	if v == nil {
2080		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
2081			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
2082		}
2083		return graphql.Null
2084	}
2085	return ec._BugEdge(ctx, sel, v)
2086}
2087
2088func (ec *executionContext) marshalOBug2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx context.Context, sel ast.SelectionSet, v models.BugWrapper) graphql.Marshaler {
2089	if v == nil {
2090		return graphql.Null
2091	}
2092	return ec._Bug(ctx, sel, v)
2093}
2094
2095// endregion ***************************** type.gotpl *****************************