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