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