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