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", "targetPrefix", "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 "targetPrefix":
2124			var err error
2125
2126			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("targetPrefix"))
2127			it.TargetPrefix, err = ec.unmarshalNString2string(ctx, v)
2128			if err != nil {
2129				return it, err
2130			}
2131		case "message":
2132			var err error
2133
2134			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("message"))
2135			it.Message, err = ec.unmarshalNString2string(ctx, v)
2136			if err != nil {
2137				return it, err
2138			}
2139		case "files":
2140			var err error
2141
2142			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("files"))
2143			it.Files, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, v)
2144			if err != nil {
2145				return it, err
2146			}
2147		}
2148	}
2149
2150	return it, nil
2151}
2152
2153func (ec *executionContext) unmarshalInputNewBugInput(ctx context.Context, obj interface{}) (models.NewBugInput, error) {
2154	var it models.NewBugInput
2155	asMap := map[string]interface{}{}
2156	for k, v := range obj.(map[string]interface{}) {
2157		asMap[k] = v
2158	}
2159
2160	fieldsInOrder := [...]string{"clientMutationId", "repoRef", "title", "message", "files"}
2161	for _, k := range fieldsInOrder {
2162		v, ok := asMap[k]
2163		if !ok {
2164			continue
2165		}
2166		switch k {
2167		case "clientMutationId":
2168			var err error
2169
2170			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientMutationId"))
2171			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
2172			if err != nil {
2173				return it, err
2174			}
2175		case "repoRef":
2176			var err error
2177
2178			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("repoRef"))
2179			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
2180			if err != nil {
2181				return it, err
2182			}
2183		case "title":
2184			var err error
2185
2186			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("title"))
2187			it.Title, err = ec.unmarshalNString2string(ctx, v)
2188			if err != nil {
2189				return it, err
2190			}
2191		case "message":
2192			var err error
2193
2194			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("message"))
2195			it.Message, err = ec.unmarshalNString2string(ctx, v)
2196			if err != nil {
2197				return it, err
2198			}
2199		case "files":
2200			var err error
2201
2202			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("files"))
2203			it.Files, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, v)
2204			if err != nil {
2205				return it, err
2206			}
2207		}
2208	}
2209
2210	return it, nil
2211}
2212
2213func (ec *executionContext) unmarshalInputOpenBugInput(ctx context.Context, obj interface{}) (models.OpenBugInput, error) {
2214	var it models.OpenBugInput
2215	asMap := map[string]interface{}{}
2216	for k, v := range obj.(map[string]interface{}) {
2217		asMap[k] = v
2218	}
2219
2220	fieldsInOrder := [...]string{"clientMutationId", "repoRef", "prefix"}
2221	for _, k := range fieldsInOrder {
2222		v, ok := asMap[k]
2223		if !ok {
2224			continue
2225		}
2226		switch k {
2227		case "clientMutationId":
2228			var err error
2229
2230			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientMutationId"))
2231			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
2232			if err != nil {
2233				return it, err
2234			}
2235		case "repoRef":
2236			var err error
2237
2238			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("repoRef"))
2239			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
2240			if err != nil {
2241				return it, err
2242			}
2243		case "prefix":
2244			var err error
2245
2246			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("prefix"))
2247			it.Prefix, err = ec.unmarshalNString2string(ctx, v)
2248			if err != nil {
2249				return it, err
2250			}
2251		}
2252	}
2253
2254	return it, nil
2255}
2256
2257func (ec *executionContext) unmarshalInputSetTitleInput(ctx context.Context, obj interface{}) (models.SetTitleInput, error) {
2258	var it models.SetTitleInput
2259	asMap := map[string]interface{}{}
2260	for k, v := range obj.(map[string]interface{}) {
2261		asMap[k] = v
2262	}
2263
2264	fieldsInOrder := [...]string{"clientMutationId", "repoRef", "prefix", "title"}
2265	for _, k := range fieldsInOrder {
2266		v, ok := asMap[k]
2267		if !ok {
2268			continue
2269		}
2270		switch k {
2271		case "clientMutationId":
2272			var err error
2273
2274			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientMutationId"))
2275			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
2276			if err != nil {
2277				return it, err
2278			}
2279		case "repoRef":
2280			var err error
2281
2282			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("repoRef"))
2283			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
2284			if err != nil {
2285				return it, err
2286			}
2287		case "prefix":
2288			var err error
2289
2290			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("prefix"))
2291			it.Prefix, err = ec.unmarshalNString2string(ctx, v)
2292			if err != nil {
2293				return it, err
2294			}
2295		case "title":
2296			var err error
2297
2298			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("title"))
2299			it.Title, err = ec.unmarshalNString2string(ctx, v)
2300			if err != nil {
2301				return it, err
2302			}
2303		}
2304	}
2305
2306	return it, nil
2307}
2308
2309// endregion **************************** input.gotpl *****************************
2310
2311// region    ************************** interface.gotpl ***************************
2312
2313// endregion ************************** interface.gotpl ***************************
2314
2315// region    **************************** object.gotpl ****************************
2316
2317var addCommentAndCloseBugPayloadImplementors = []string{"AddCommentAndCloseBugPayload"}
2318
2319func (ec *executionContext) _AddCommentAndCloseBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.AddCommentAndCloseBugPayload) graphql.Marshaler {
2320	fields := graphql.CollectFields(ec.OperationContext, sel, addCommentAndCloseBugPayloadImplementors)
2321	out := graphql.NewFieldSet(fields)
2322	var invalids uint32
2323	for i, field := range fields {
2324		switch field.Name {
2325		case "__typename":
2326			out.Values[i] = graphql.MarshalString("AddCommentAndCloseBugPayload")
2327		case "clientMutationId":
2328
2329			out.Values[i] = ec._AddCommentAndCloseBugPayload_clientMutationId(ctx, field, obj)
2330
2331		case "bug":
2332
2333			out.Values[i] = ec._AddCommentAndCloseBugPayload_bug(ctx, field, obj)
2334
2335			if out.Values[i] == graphql.Null {
2336				invalids++
2337			}
2338		case "commentOperation":
2339
2340			out.Values[i] = ec._AddCommentAndCloseBugPayload_commentOperation(ctx, field, obj)
2341
2342			if out.Values[i] == graphql.Null {
2343				invalids++
2344			}
2345		case "statusOperation":
2346
2347			out.Values[i] = ec._AddCommentAndCloseBugPayload_statusOperation(ctx, field, obj)
2348
2349			if out.Values[i] == graphql.Null {
2350				invalids++
2351			}
2352		default:
2353			panic("unknown field " + strconv.Quote(field.Name))
2354		}
2355	}
2356	out.Dispatch()
2357	if invalids > 0 {
2358		return graphql.Null
2359	}
2360	return out
2361}
2362
2363var addCommentAndReopenBugPayloadImplementors = []string{"AddCommentAndReopenBugPayload"}
2364
2365func (ec *executionContext) _AddCommentAndReopenBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.AddCommentAndReopenBugPayload) graphql.Marshaler {
2366	fields := graphql.CollectFields(ec.OperationContext, sel, addCommentAndReopenBugPayloadImplementors)
2367	out := graphql.NewFieldSet(fields)
2368	var invalids uint32
2369	for i, field := range fields {
2370		switch field.Name {
2371		case "__typename":
2372			out.Values[i] = graphql.MarshalString("AddCommentAndReopenBugPayload")
2373		case "clientMutationId":
2374
2375			out.Values[i] = ec._AddCommentAndReopenBugPayload_clientMutationId(ctx, field, obj)
2376
2377		case "bug":
2378
2379			out.Values[i] = ec._AddCommentAndReopenBugPayload_bug(ctx, field, obj)
2380
2381			if out.Values[i] == graphql.Null {
2382				invalids++
2383			}
2384		case "commentOperation":
2385
2386			out.Values[i] = ec._AddCommentAndReopenBugPayload_commentOperation(ctx, field, obj)
2387
2388			if out.Values[i] == graphql.Null {
2389				invalids++
2390			}
2391		case "statusOperation":
2392
2393			out.Values[i] = ec._AddCommentAndReopenBugPayload_statusOperation(ctx, field, obj)
2394
2395			if out.Values[i] == graphql.Null {
2396				invalids++
2397			}
2398		default:
2399			panic("unknown field " + strconv.Quote(field.Name))
2400		}
2401	}
2402	out.Dispatch()
2403	if invalids > 0 {
2404		return graphql.Null
2405	}
2406	return out
2407}
2408
2409var addCommentPayloadImplementors = []string{"AddCommentPayload"}
2410
2411func (ec *executionContext) _AddCommentPayload(ctx context.Context, sel ast.SelectionSet, obj *models.AddCommentPayload) graphql.Marshaler {
2412	fields := graphql.CollectFields(ec.OperationContext, sel, addCommentPayloadImplementors)
2413	out := graphql.NewFieldSet(fields)
2414	var invalids uint32
2415	for i, field := range fields {
2416		switch field.Name {
2417		case "__typename":
2418			out.Values[i] = graphql.MarshalString("AddCommentPayload")
2419		case "clientMutationId":
2420
2421			out.Values[i] = ec._AddCommentPayload_clientMutationId(ctx, field, obj)
2422
2423		case "bug":
2424
2425			out.Values[i] = ec._AddCommentPayload_bug(ctx, field, obj)
2426
2427			if out.Values[i] == graphql.Null {
2428				invalids++
2429			}
2430		case "operation":
2431
2432			out.Values[i] = ec._AddCommentPayload_operation(ctx, field, obj)
2433
2434			if out.Values[i] == graphql.Null {
2435				invalids++
2436			}
2437		default:
2438			panic("unknown field " + strconv.Quote(field.Name))
2439		}
2440	}
2441	out.Dispatch()
2442	if invalids > 0 {
2443		return graphql.Null
2444	}
2445	return out
2446}
2447
2448var changeLabelPayloadImplementors = []string{"ChangeLabelPayload"}
2449
2450func (ec *executionContext) _ChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, obj *models.ChangeLabelPayload) graphql.Marshaler {
2451	fields := graphql.CollectFields(ec.OperationContext, sel, changeLabelPayloadImplementors)
2452	out := graphql.NewFieldSet(fields)
2453	var invalids uint32
2454	for i, field := range fields {
2455		switch field.Name {
2456		case "__typename":
2457			out.Values[i] = graphql.MarshalString("ChangeLabelPayload")
2458		case "clientMutationId":
2459
2460			out.Values[i] = ec._ChangeLabelPayload_clientMutationId(ctx, field, obj)
2461
2462		case "bug":
2463
2464			out.Values[i] = ec._ChangeLabelPayload_bug(ctx, field, obj)
2465
2466			if out.Values[i] == graphql.Null {
2467				invalids++
2468			}
2469		case "operation":
2470
2471			out.Values[i] = ec._ChangeLabelPayload_operation(ctx, field, obj)
2472
2473			if out.Values[i] == graphql.Null {
2474				invalids++
2475			}
2476		case "results":
2477
2478			out.Values[i] = ec._ChangeLabelPayload_results(ctx, field, obj)
2479
2480			if out.Values[i] == graphql.Null {
2481				invalids++
2482			}
2483		default:
2484			panic("unknown field " + strconv.Quote(field.Name))
2485		}
2486	}
2487	out.Dispatch()
2488	if invalids > 0 {
2489		return graphql.Null
2490	}
2491	return out
2492}
2493
2494var closeBugPayloadImplementors = []string{"CloseBugPayload"}
2495
2496func (ec *executionContext) _CloseBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.CloseBugPayload) graphql.Marshaler {
2497	fields := graphql.CollectFields(ec.OperationContext, sel, closeBugPayloadImplementors)
2498	out := graphql.NewFieldSet(fields)
2499	var invalids uint32
2500	for i, field := range fields {
2501		switch field.Name {
2502		case "__typename":
2503			out.Values[i] = graphql.MarshalString("CloseBugPayload")
2504		case "clientMutationId":
2505
2506			out.Values[i] = ec._CloseBugPayload_clientMutationId(ctx, field, obj)
2507
2508		case "bug":
2509
2510			out.Values[i] = ec._CloseBugPayload_bug(ctx, field, obj)
2511
2512			if out.Values[i] == graphql.Null {
2513				invalids++
2514			}
2515		case "operation":
2516
2517			out.Values[i] = ec._CloseBugPayload_operation(ctx, field, obj)
2518
2519			if out.Values[i] == graphql.Null {
2520				invalids++
2521			}
2522		default:
2523			panic("unknown field " + strconv.Quote(field.Name))
2524		}
2525	}
2526	out.Dispatch()
2527	if invalids > 0 {
2528		return graphql.Null
2529	}
2530	return out
2531}
2532
2533var editCommentPayloadImplementors = []string{"EditCommentPayload"}
2534
2535func (ec *executionContext) _EditCommentPayload(ctx context.Context, sel ast.SelectionSet, obj *models.EditCommentPayload) graphql.Marshaler {
2536	fields := graphql.CollectFields(ec.OperationContext, sel, editCommentPayloadImplementors)
2537	out := graphql.NewFieldSet(fields)
2538	var invalids uint32
2539	for i, field := range fields {
2540		switch field.Name {
2541		case "__typename":
2542			out.Values[i] = graphql.MarshalString("EditCommentPayload")
2543		case "clientMutationId":
2544
2545			out.Values[i] = ec._EditCommentPayload_clientMutationId(ctx, field, obj)
2546
2547		case "bug":
2548
2549			out.Values[i] = ec._EditCommentPayload_bug(ctx, field, obj)
2550
2551			if out.Values[i] == graphql.Null {
2552				invalids++
2553			}
2554		case "operation":
2555
2556			out.Values[i] = ec._EditCommentPayload_operation(ctx, field, obj)
2557
2558			if out.Values[i] == graphql.Null {
2559				invalids++
2560			}
2561		default:
2562			panic("unknown field " + strconv.Quote(field.Name))
2563		}
2564	}
2565	out.Dispatch()
2566	if invalids > 0 {
2567		return graphql.Null
2568	}
2569	return out
2570}
2571
2572var labelChangeResultImplementors = []string{"LabelChangeResult"}
2573
2574func (ec *executionContext) _LabelChangeResult(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeResult) graphql.Marshaler {
2575	fields := graphql.CollectFields(ec.OperationContext, sel, labelChangeResultImplementors)
2576	out := graphql.NewFieldSet(fields)
2577	var invalids uint32
2578	for i, field := range fields {
2579		switch field.Name {
2580		case "__typename":
2581			out.Values[i] = graphql.MarshalString("LabelChangeResult")
2582		case "label":
2583
2584			out.Values[i] = ec._LabelChangeResult_label(ctx, field, obj)
2585
2586			if out.Values[i] == graphql.Null {
2587				invalids++
2588			}
2589		case "status":
2590
2591			out.Values[i] = ec._LabelChangeResult_status(ctx, field, obj)
2592
2593			if out.Values[i] == graphql.Null {
2594				invalids++
2595			}
2596		default:
2597			panic("unknown field " + strconv.Quote(field.Name))
2598		}
2599	}
2600	out.Dispatch()
2601	if invalids > 0 {
2602		return graphql.Null
2603	}
2604	return out
2605}
2606
2607var newBugPayloadImplementors = []string{"NewBugPayload"}
2608
2609func (ec *executionContext) _NewBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.NewBugPayload) graphql.Marshaler {
2610	fields := graphql.CollectFields(ec.OperationContext, sel, newBugPayloadImplementors)
2611	out := graphql.NewFieldSet(fields)
2612	var invalids uint32
2613	for i, field := range fields {
2614		switch field.Name {
2615		case "__typename":
2616			out.Values[i] = graphql.MarshalString("NewBugPayload")
2617		case "clientMutationId":
2618
2619			out.Values[i] = ec._NewBugPayload_clientMutationId(ctx, field, obj)
2620
2621		case "bug":
2622
2623			out.Values[i] = ec._NewBugPayload_bug(ctx, field, obj)
2624
2625			if out.Values[i] == graphql.Null {
2626				invalids++
2627			}
2628		case "operation":
2629
2630			out.Values[i] = ec._NewBugPayload_operation(ctx, field, obj)
2631
2632			if out.Values[i] == graphql.Null {
2633				invalids++
2634			}
2635		default:
2636			panic("unknown field " + strconv.Quote(field.Name))
2637		}
2638	}
2639	out.Dispatch()
2640	if invalids > 0 {
2641		return graphql.Null
2642	}
2643	return out
2644}
2645
2646var openBugPayloadImplementors = []string{"OpenBugPayload"}
2647
2648func (ec *executionContext) _OpenBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.OpenBugPayload) graphql.Marshaler {
2649	fields := graphql.CollectFields(ec.OperationContext, sel, openBugPayloadImplementors)
2650	out := graphql.NewFieldSet(fields)
2651	var invalids uint32
2652	for i, field := range fields {
2653		switch field.Name {
2654		case "__typename":
2655			out.Values[i] = graphql.MarshalString("OpenBugPayload")
2656		case "clientMutationId":
2657
2658			out.Values[i] = ec._OpenBugPayload_clientMutationId(ctx, field, obj)
2659
2660		case "bug":
2661
2662			out.Values[i] = ec._OpenBugPayload_bug(ctx, field, obj)
2663
2664			if out.Values[i] == graphql.Null {
2665				invalids++
2666			}
2667		case "operation":
2668
2669			out.Values[i] = ec._OpenBugPayload_operation(ctx, field, obj)
2670
2671			if out.Values[i] == graphql.Null {
2672				invalids++
2673			}
2674		default:
2675			panic("unknown field " + strconv.Quote(field.Name))
2676		}
2677	}
2678	out.Dispatch()
2679	if invalids > 0 {
2680		return graphql.Null
2681	}
2682	return out
2683}
2684
2685var setTitlePayloadImplementors = []string{"SetTitlePayload"}
2686
2687func (ec *executionContext) _SetTitlePayload(ctx context.Context, sel ast.SelectionSet, obj *models.SetTitlePayload) graphql.Marshaler {
2688	fields := graphql.CollectFields(ec.OperationContext, sel, setTitlePayloadImplementors)
2689	out := graphql.NewFieldSet(fields)
2690	var invalids uint32
2691	for i, field := range fields {
2692		switch field.Name {
2693		case "__typename":
2694			out.Values[i] = graphql.MarshalString("SetTitlePayload")
2695		case "clientMutationId":
2696
2697			out.Values[i] = ec._SetTitlePayload_clientMutationId(ctx, field, obj)
2698
2699		case "bug":
2700
2701			out.Values[i] = ec._SetTitlePayload_bug(ctx, field, obj)
2702
2703			if out.Values[i] == graphql.Null {
2704				invalids++
2705			}
2706		case "operation":
2707
2708			out.Values[i] = ec._SetTitlePayload_operation(ctx, field, obj)
2709
2710			if out.Values[i] == graphql.Null {
2711				invalids++
2712			}
2713		default:
2714			panic("unknown field " + strconv.Quote(field.Name))
2715		}
2716	}
2717	out.Dispatch()
2718	if invalids > 0 {
2719		return graphql.Null
2720	}
2721	return out
2722}
2723
2724// endregion **************************** object.gotpl ****************************
2725
2726// region    ***************************** type.gotpl *****************************
2727
2728func (ec *executionContext) unmarshalNAddCommentAndCloseBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentAndCloseBugInput(ctx context.Context, v interface{}) (models.AddCommentAndCloseBugInput, error) {
2729	res, err := ec.unmarshalInputAddCommentAndCloseBugInput(ctx, v)
2730	return res, graphql.ErrorOnPath(ctx, err)
2731}
2732
2733func (ec *executionContext) marshalNAddCommentAndCloseBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentAndCloseBugPayload(ctx context.Context, sel ast.SelectionSet, v models.AddCommentAndCloseBugPayload) graphql.Marshaler {
2734	return ec._AddCommentAndCloseBugPayload(ctx, sel, &v)
2735}
2736
2737func (ec *executionContext) marshalNAddCommentAndCloseBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentAndCloseBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.AddCommentAndCloseBugPayload) graphql.Marshaler {
2738	if v == nil {
2739		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
2740			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
2741		}
2742		return graphql.Null
2743	}
2744	return ec._AddCommentAndCloseBugPayload(ctx, sel, v)
2745}
2746
2747func (ec *executionContext) unmarshalNAddCommentAndReopenBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentAndReopenBugInput(ctx context.Context, v interface{}) (models.AddCommentAndReopenBugInput, error) {
2748	res, err := ec.unmarshalInputAddCommentAndReopenBugInput(ctx, v)
2749	return res, graphql.ErrorOnPath(ctx, err)
2750}
2751
2752func (ec *executionContext) marshalNAddCommentAndReopenBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentAndReopenBugPayload(ctx context.Context, sel ast.SelectionSet, v models.AddCommentAndReopenBugPayload) graphql.Marshaler {
2753	return ec._AddCommentAndReopenBugPayload(ctx, sel, &v)
2754}
2755
2756func (ec *executionContext) marshalNAddCommentAndReopenBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentAndReopenBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.AddCommentAndReopenBugPayload) graphql.Marshaler {
2757	if v == nil {
2758		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
2759			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
2760		}
2761		return graphql.Null
2762	}
2763	return ec._AddCommentAndReopenBugPayload(ctx, sel, v)
2764}
2765
2766func (ec *executionContext) unmarshalNAddCommentInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentInput(ctx context.Context, v interface{}) (models.AddCommentInput, error) {
2767	res, err := ec.unmarshalInputAddCommentInput(ctx, v)
2768	return res, graphql.ErrorOnPath(ctx, err)
2769}
2770
2771func (ec *executionContext) marshalNAddCommentPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx context.Context, sel ast.SelectionSet, v models.AddCommentPayload) graphql.Marshaler {
2772	return ec._AddCommentPayload(ctx, sel, &v)
2773}
2774
2775func (ec *executionContext) marshalNAddCommentPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx context.Context, sel ast.SelectionSet, v *models.AddCommentPayload) graphql.Marshaler {
2776	if v == nil {
2777		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
2778			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
2779		}
2780		return graphql.Null
2781	}
2782	return ec._AddCommentPayload(ctx, sel, v)
2783}
2784
2785func (ec *executionContext) marshalNChangeLabelPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, v models.ChangeLabelPayload) graphql.Marshaler {
2786	return ec._ChangeLabelPayload(ctx, sel, &v)
2787}
2788
2789func (ec *executionContext) marshalNChangeLabelPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, v *models.ChangeLabelPayload) graphql.Marshaler {
2790	if v == nil {
2791		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
2792			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
2793		}
2794		return graphql.Null
2795	}
2796	return ec._ChangeLabelPayload(ctx, sel, v)
2797}
2798
2799func (ec *executionContext) unmarshalNCloseBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCloseBugInput(ctx context.Context, v interface{}) (models.CloseBugInput, error) {
2800	res, err := ec.unmarshalInputCloseBugInput(ctx, v)
2801	return res, graphql.ErrorOnPath(ctx, err)
2802}
2803
2804func (ec *executionContext) marshalNCloseBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx context.Context, sel ast.SelectionSet, v models.CloseBugPayload) graphql.Marshaler {
2805	return ec._CloseBugPayload(ctx, sel, &v)
2806}
2807
2808func (ec *executionContext) marshalNCloseBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.CloseBugPayload) graphql.Marshaler {
2809	if v == nil {
2810		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
2811			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
2812		}
2813		return graphql.Null
2814	}
2815	return ec._CloseBugPayload(ctx, sel, v)
2816}
2817
2818func (ec *executionContext) unmarshalNEditCommentInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐEditCommentInput(ctx context.Context, v interface{}) (models.EditCommentInput, error) {
2819	res, err := ec.unmarshalInputEditCommentInput(ctx, v)
2820	return res, graphql.ErrorOnPath(ctx, err)
2821}
2822
2823func (ec *executionContext) marshalNEditCommentPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐEditCommentPayload(ctx context.Context, sel ast.SelectionSet, v models.EditCommentPayload) graphql.Marshaler {
2824	return ec._EditCommentPayload(ctx, sel, &v)
2825}
2826
2827func (ec *executionContext) marshalNEditCommentPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐEditCommentPayload(ctx context.Context, sel ast.SelectionSet, v *models.EditCommentPayload) graphql.Marshaler {
2828	if v == nil {
2829		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
2830			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
2831		}
2832		return graphql.Null
2833	}
2834	return ec._EditCommentPayload(ctx, sel, v)
2835}
2836
2837func (ec *executionContext) marshalNLabelChangeResult2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋentitiesᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v []*bug.LabelChangeResult) graphql.Marshaler {
2838	ret := make(graphql.Array, len(v))
2839	var wg sync.WaitGroup
2840	isLen1 := len(v) == 1
2841	if !isLen1 {
2842		wg.Add(len(v))
2843	}
2844	for i := range v {
2845		i := i
2846		fc := &graphql.FieldContext{
2847			Index:  &i,
2848			Result: &v[i],
2849		}
2850		ctx := graphql.WithFieldContext(ctx, fc)
2851		f := func(i int) {
2852			defer func() {
2853				if r := recover(); r != nil {
2854					ec.Error(ctx, ec.Recover(ctx, r))
2855					ret = nil
2856				}
2857			}()
2858			if !isLen1 {
2859				defer wg.Done()
2860			}
2861			ret[i] = ec.marshalOLabelChangeResult2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋentitiesᚋbugᚐLabelChangeResult(ctx, sel, v[i])
2862		}
2863		if isLen1 {
2864			f(i)
2865		} else {
2866			go f(i)
2867		}
2868
2869	}
2870	wg.Wait()
2871
2872	return ret
2873}
2874
2875func (ec *executionContext) unmarshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋentitiesᚋbugᚐLabelChangeStatus(ctx context.Context, v interface{}) (bug.LabelChangeStatus, error) {
2876	var res bug.LabelChangeStatus
2877	err := res.UnmarshalGQL(v)
2878	return res, graphql.ErrorOnPath(ctx, err)
2879}
2880
2881func (ec *executionContext) marshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋentitiesᚋbugᚐLabelChangeStatus(ctx context.Context, sel ast.SelectionSet, v bug.LabelChangeStatus) graphql.Marshaler {
2882	return v
2883}
2884
2885func (ec *executionContext) unmarshalNNewBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐNewBugInput(ctx context.Context, v interface{}) (models.NewBugInput, error) {
2886	res, err := ec.unmarshalInputNewBugInput(ctx, v)
2887	return res, graphql.ErrorOnPath(ctx, err)
2888}
2889
2890func (ec *executionContext) marshalNNewBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐNewBugPayload(ctx context.Context, sel ast.SelectionSet, v models.NewBugPayload) graphql.Marshaler {
2891	return ec._NewBugPayload(ctx, sel, &v)
2892}
2893
2894func (ec *executionContext) marshalNNewBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐNewBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.NewBugPayload) graphql.Marshaler {
2895	if v == nil {
2896		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
2897			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
2898		}
2899		return graphql.Null
2900	}
2901	return ec._NewBugPayload(ctx, sel, v)
2902}
2903
2904func (ec *executionContext) unmarshalNOpenBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOpenBugInput(ctx context.Context, v interface{}) (models.OpenBugInput, error) {
2905	res, err := ec.unmarshalInputOpenBugInput(ctx, v)
2906	return res, graphql.ErrorOnPath(ctx, err)
2907}
2908
2909func (ec *executionContext) marshalNOpenBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx context.Context, sel ast.SelectionSet, v models.OpenBugPayload) graphql.Marshaler {
2910	return ec._OpenBugPayload(ctx, sel, &v)
2911}
2912
2913func (ec *executionContext) marshalNOpenBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.OpenBugPayload) graphql.Marshaler {
2914	if v == nil {
2915		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
2916			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
2917		}
2918		return graphql.Null
2919	}
2920	return ec._OpenBugPayload(ctx, sel, v)
2921}
2922
2923func (ec *executionContext) unmarshalNSetTitleInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐSetTitleInput(ctx context.Context, v interface{}) (models.SetTitleInput, error) {
2924	res, err := ec.unmarshalInputSetTitleInput(ctx, v)
2925	return res, graphql.ErrorOnPath(ctx, err)
2926}
2927
2928func (ec *executionContext) marshalNSetTitlePayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx context.Context, sel ast.SelectionSet, v models.SetTitlePayload) graphql.Marshaler {
2929	return ec._SetTitlePayload(ctx, sel, &v)
2930}
2931
2932func (ec *executionContext) marshalNSetTitlePayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx context.Context, sel ast.SelectionSet, v *models.SetTitlePayload) graphql.Marshaler {
2933	if v == nil {
2934		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
2935			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
2936		}
2937		return graphql.Null
2938	}
2939	return ec._SetTitlePayload(ctx, sel, v)
2940}
2941
2942func (ec *executionContext) unmarshalOChangeLabelInput2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx context.Context, v interface{}) (*models.ChangeLabelInput, error) {
2943	if v == nil {
2944		return nil, nil
2945	}
2946	res, err := ec.unmarshalInputChangeLabelInput(ctx, v)
2947	return &res, graphql.ErrorOnPath(ctx, err)
2948}
2949
2950func (ec *executionContext) marshalOLabelChangeResult2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋentitiesᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v *bug.LabelChangeResult) graphql.Marshaler {
2951	if v == nil {
2952		return graphql.Null
2953	}
2954	return ec._LabelChangeResult(ctx, sel, v)
2955}
2956
2957// endregion ***************************** type.gotpl *****************************