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