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