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