1// Code generated by github.com/99designs/gqlgen, DO NOT EDIT.
   2
   3package graph
   4
   5import (
   6	"bytes"
   7	"context"
   8	"errors"
   9	"fmt"
  10	"strconv"
  11	"sync"
  12	"time"
  13
  14	"github.com/99designs/gqlgen/graphql"
  15	"github.com/99designs/gqlgen/graphql/introspection"
  16	"github.com/MichaelMure/git-bug/bug"
  17	"github.com/MichaelMure/git-bug/graphql/models"
  18	"github.com/MichaelMure/git-bug/identity"
  19	"github.com/MichaelMure/git-bug/util/git"
  20	"github.com/vektah/gqlparser"
  21	"github.com/vektah/gqlparser/ast"
  22)
  23
  24// NewExecutableSchema creates an ExecutableSchema from the ResolverRoot interface.
  25func NewExecutableSchema(cfg Config) graphql.ExecutableSchema {
  26	return &executableSchema{
  27		resolvers:  cfg.Resolvers,
  28		directives: cfg.Directives,
  29		complexity: cfg.Complexity,
  30	}
  31}
  32
  33type Config struct {
  34	Resolvers  ResolverRoot
  35	Directives DirectiveRoot
  36	Complexity ComplexityRoot
  37}
  38
  39type ResolverRoot interface {
  40	AddCommentOperation() AddCommentOperationResolver
  41	AddCommentTimelineItem() AddCommentTimelineItemResolver
  42	Bug() BugResolver
  43	CommentHistoryStep() CommentHistoryStepResolver
  44	CreateOperation() CreateOperationResolver
  45	CreateTimelineItem() CreateTimelineItemResolver
  46	EditCommentOperation() EditCommentOperationResolver
  47	Identity() IdentityResolver
  48	LabelChangeOperation() LabelChangeOperationResolver
  49	LabelChangeTimelineItem() LabelChangeTimelineItemResolver
  50	Mutation() MutationResolver
  51	Query() QueryResolver
  52	Repository() RepositoryResolver
  53	SetStatusOperation() SetStatusOperationResolver
  54	SetStatusTimelineItem() SetStatusTimelineItemResolver
  55	SetTitleOperation() SetTitleOperationResolver
  56	SetTitleTimelineItem() SetTitleTimelineItemResolver
  57}
  58
  59type DirectiveRoot struct {
  60}
  61
  62type ComplexityRoot struct {
  63	AddCommentOperation struct {
  64		Hash    func(childComplexity int) int
  65		Author  func(childComplexity int) int
  66		Date    func(childComplexity int) int
  67		Message func(childComplexity int) int
  68		Files   func(childComplexity int) int
  69	}
  70
  71	AddCommentTimelineItem struct {
  72		Hash           func(childComplexity int) int
  73		Author         func(childComplexity int) int
  74		Message        func(childComplexity int) int
  75		MessageIsEmpty func(childComplexity int) int
  76		Files          func(childComplexity int) int
  77		CreatedAt      func(childComplexity int) int
  78		LastEdit       func(childComplexity int) int
  79		Edited         func(childComplexity int) int
  80		History        func(childComplexity int) int
  81	}
  82
  83	Bug struct {
  84		Id         func(childComplexity int) int
  85		HumanId    func(childComplexity int) int
  86		Status     func(childComplexity int) int
  87		Title      func(childComplexity int) int
  88		Labels     func(childComplexity int) int
  89		Author     func(childComplexity int) int
  90		CreatedAt  func(childComplexity int) int
  91		LastEdit   func(childComplexity int) int
  92		Comments   func(childComplexity int, after *string, before *string, first *int, last *int) int
  93		Timeline   func(childComplexity int, after *string, before *string, first *int, last *int) int
  94		Operations func(childComplexity int, after *string, before *string, first *int, last *int) int
  95	}
  96
  97	BugConnection struct {
  98		Edges      func(childComplexity int) int
  99		Nodes      func(childComplexity int) int
 100		PageInfo   func(childComplexity int) int
 101		TotalCount func(childComplexity int) int
 102	}
 103
 104	BugEdge struct {
 105		Cursor func(childComplexity int) int
 106		Node   func(childComplexity int) int
 107	}
 108
 109	Comment struct {
 110		Author  func(childComplexity int) int
 111		Message func(childComplexity int) int
 112		Files   func(childComplexity int) int
 113	}
 114
 115	CommentConnection struct {
 116		Edges      func(childComplexity int) int
 117		Nodes      func(childComplexity int) int
 118		PageInfo   func(childComplexity int) int
 119		TotalCount func(childComplexity int) int
 120	}
 121
 122	CommentEdge struct {
 123		Cursor func(childComplexity int) int
 124		Node   func(childComplexity int) int
 125	}
 126
 127	CommentHistoryStep struct {
 128		Message func(childComplexity int) int
 129		Date    func(childComplexity int) int
 130	}
 131
 132	CreateOperation struct {
 133		Hash    func(childComplexity int) int
 134		Author  func(childComplexity int) int
 135		Date    func(childComplexity int) int
 136		Title   func(childComplexity int) int
 137		Message func(childComplexity int) int
 138		Files   func(childComplexity int) int
 139	}
 140
 141	CreateTimelineItem struct {
 142		Hash           func(childComplexity int) int
 143		Author         func(childComplexity int) int
 144		Message        func(childComplexity int) int
 145		MessageIsEmpty func(childComplexity int) int
 146		Files          func(childComplexity int) int
 147		CreatedAt      func(childComplexity int) int
 148		LastEdit       func(childComplexity int) int
 149		Edited         func(childComplexity int) int
 150		History        func(childComplexity int) int
 151	}
 152
 153	EditCommentOperation struct {
 154		Hash    func(childComplexity int) int
 155		Author  func(childComplexity int) int
 156		Date    func(childComplexity int) int
 157		Target  func(childComplexity int) int
 158		Message func(childComplexity int) int
 159		Files   func(childComplexity int) int
 160	}
 161
 162	Identity struct {
 163		Name        func(childComplexity int) int
 164		Email       func(childComplexity int) int
 165		Login       func(childComplexity int) int
 166		DisplayName func(childComplexity int) int
 167		AvatarUrl   func(childComplexity int) int
 168	}
 169
 170	LabelChangeOperation struct {
 171		Hash    func(childComplexity int) int
 172		Author  func(childComplexity int) int
 173		Date    func(childComplexity int) int
 174		Added   func(childComplexity int) int
 175		Removed func(childComplexity int) int
 176	}
 177
 178	LabelChangeTimelineItem struct {
 179		Hash    func(childComplexity int) int
 180		Author  func(childComplexity int) int
 181		Date    func(childComplexity int) int
 182		Added   func(childComplexity int) int
 183		Removed func(childComplexity int) int
 184	}
 185
 186	Mutation struct {
 187		NewBug       func(childComplexity int, repoRef *string, title string, message string, files []git.Hash) int
 188		AddComment   func(childComplexity int, repoRef *string, prefix string, message string, files []git.Hash) int
 189		ChangeLabels func(childComplexity int, repoRef *string, prefix string, added []string, removed []string) int
 190		Open         func(childComplexity int, repoRef *string, prefix string) int
 191		Close        func(childComplexity int, repoRef *string, prefix string) int
 192		SetTitle     func(childComplexity int, repoRef *string, prefix string, title string) int
 193		Commit       func(childComplexity int, repoRef *string, prefix string) int
 194	}
 195
 196	OperationConnection struct {
 197		Edges      func(childComplexity int) int
 198		Nodes      func(childComplexity int) int
 199		PageInfo   func(childComplexity int) int
 200		TotalCount func(childComplexity int) int
 201	}
 202
 203	OperationEdge struct {
 204		Cursor func(childComplexity int) int
 205		Node   func(childComplexity int) int
 206	}
 207
 208	PageInfo struct {
 209		HasNextPage     func(childComplexity int) int
 210		HasPreviousPage func(childComplexity int) int
 211		StartCursor     func(childComplexity int) int
 212		EndCursor       func(childComplexity int) int
 213	}
 214
 215	Query struct {
 216		DefaultRepository func(childComplexity int) int
 217		Repository        func(childComplexity int, id string) int
 218	}
 219
 220	Repository struct {
 221		AllBugs func(childComplexity int, after *string, before *string, first *int, last *int, query *string) int
 222		Bug     func(childComplexity int, prefix string) int
 223	}
 224
 225	SetStatusOperation struct {
 226		Hash   func(childComplexity int) int
 227		Author func(childComplexity int) int
 228		Date   func(childComplexity int) int
 229		Status func(childComplexity int) int
 230	}
 231
 232	SetStatusTimelineItem struct {
 233		Hash   func(childComplexity int) int
 234		Author func(childComplexity int) int
 235		Date   func(childComplexity int) int
 236		Status func(childComplexity int) int
 237	}
 238
 239	SetTitleOperation struct {
 240		Hash   func(childComplexity int) int
 241		Author func(childComplexity int) int
 242		Date   func(childComplexity int) int
 243		Title  func(childComplexity int) int
 244		Was    func(childComplexity int) int
 245	}
 246
 247	SetTitleTimelineItem struct {
 248		Hash   func(childComplexity int) int
 249		Author func(childComplexity int) int
 250		Date   func(childComplexity int) int
 251		Title  func(childComplexity int) int
 252		Was    func(childComplexity int) int
 253	}
 254
 255	TimelineItemConnection struct {
 256		Edges      func(childComplexity int) int
 257		Nodes      func(childComplexity int) int
 258		PageInfo   func(childComplexity int) int
 259		TotalCount func(childComplexity int) int
 260	}
 261
 262	TimelineItemEdge struct {
 263		Cursor func(childComplexity int) int
 264		Node   func(childComplexity int) int
 265	}
 266}
 267
 268type AddCommentOperationResolver interface {
 269	Date(ctx context.Context, obj *bug.AddCommentOperation) (time.Time, error)
 270}
 271type AddCommentTimelineItemResolver interface {
 272	CreatedAt(ctx context.Context, obj *bug.AddCommentTimelineItem) (time.Time, error)
 273	LastEdit(ctx context.Context, obj *bug.AddCommentTimelineItem) (time.Time, error)
 274}
 275type BugResolver interface {
 276	Status(ctx context.Context, obj *bug.Snapshot) (models.Status, error)
 277
 278	LastEdit(ctx context.Context, obj *bug.Snapshot) (time.Time, error)
 279	Comments(ctx context.Context, obj *bug.Snapshot, after *string, before *string, first *int, last *int) (models.CommentConnection, error)
 280	Timeline(ctx context.Context, obj *bug.Snapshot, after *string, before *string, first *int, last *int) (models.TimelineItemConnection, error)
 281	Operations(ctx context.Context, obj *bug.Snapshot, after *string, before *string, first *int, last *int) (models.OperationConnection, error)
 282}
 283type CommentHistoryStepResolver interface {
 284	Date(ctx context.Context, obj *bug.CommentHistoryStep) (time.Time, error)
 285}
 286type CreateOperationResolver interface {
 287	Date(ctx context.Context, obj *bug.CreateOperation) (time.Time, error)
 288}
 289type CreateTimelineItemResolver interface {
 290	CreatedAt(ctx context.Context, obj *bug.CreateTimelineItem) (time.Time, error)
 291	LastEdit(ctx context.Context, obj *bug.CreateTimelineItem) (time.Time, error)
 292}
 293type EditCommentOperationResolver interface {
 294	Date(ctx context.Context, obj *bug.EditCommentOperation) (time.Time, error)
 295}
 296type IdentityResolver interface {
 297	Name(ctx context.Context, obj *identity.Interface) (*string, error)
 298	Email(ctx context.Context, obj *identity.Interface) (*string, error)
 299	Login(ctx context.Context, obj *identity.Interface) (*string, error)
 300	DisplayName(ctx context.Context, obj *identity.Interface) (string, error)
 301	AvatarURL(ctx context.Context, obj *identity.Interface) (*string, error)
 302}
 303type LabelChangeOperationResolver interface {
 304	Date(ctx context.Context, obj *bug.LabelChangeOperation) (time.Time, error)
 305}
 306type LabelChangeTimelineItemResolver interface {
 307	Date(ctx context.Context, obj *bug.LabelChangeTimelineItem) (time.Time, error)
 308}
 309type MutationResolver interface {
 310	NewBug(ctx context.Context, repoRef *string, title string, message string, files []git.Hash) (bug.Snapshot, error)
 311	AddComment(ctx context.Context, repoRef *string, prefix string, message string, files []git.Hash) (bug.Snapshot, error)
 312	ChangeLabels(ctx context.Context, repoRef *string, prefix string, added []string, removed []string) (bug.Snapshot, error)
 313	Open(ctx context.Context, repoRef *string, prefix string) (bug.Snapshot, error)
 314	Close(ctx context.Context, repoRef *string, prefix string) (bug.Snapshot, error)
 315	SetTitle(ctx context.Context, repoRef *string, prefix string, title string) (bug.Snapshot, error)
 316	Commit(ctx context.Context, repoRef *string, prefix string) (bug.Snapshot, error)
 317}
 318type QueryResolver interface {
 319	DefaultRepository(ctx context.Context) (*models.Repository, error)
 320	Repository(ctx context.Context, id string) (*models.Repository, error)
 321}
 322type RepositoryResolver interface {
 323	AllBugs(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int, query *string) (models.BugConnection, error)
 324	Bug(ctx context.Context, obj *models.Repository, prefix string) (*bug.Snapshot, error)
 325}
 326type SetStatusOperationResolver interface {
 327	Date(ctx context.Context, obj *bug.SetStatusOperation) (time.Time, error)
 328	Status(ctx context.Context, obj *bug.SetStatusOperation) (models.Status, error)
 329}
 330type SetStatusTimelineItemResolver interface {
 331	Date(ctx context.Context, obj *bug.SetStatusTimelineItem) (time.Time, error)
 332	Status(ctx context.Context, obj *bug.SetStatusTimelineItem) (models.Status, error)
 333}
 334type SetTitleOperationResolver interface {
 335	Date(ctx context.Context, obj *bug.SetTitleOperation) (time.Time, error)
 336}
 337type SetTitleTimelineItemResolver interface {
 338	Date(ctx context.Context, obj *bug.SetTitleTimelineItem) (time.Time, error)
 339}
 340
 341func field_Bug_comments_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
 342	args := map[string]interface{}{}
 343	var arg0 *string
 344	if tmp, ok := rawArgs["after"]; ok {
 345		var err error
 346		var ptr1 string
 347		if tmp != nil {
 348			ptr1, err = graphql.UnmarshalString(tmp)
 349			arg0 = &ptr1
 350		}
 351
 352		if err != nil {
 353			return nil, err
 354		}
 355	}
 356	args["after"] = arg0
 357	var arg1 *string
 358	if tmp, ok := rawArgs["before"]; ok {
 359		var err error
 360		var ptr1 string
 361		if tmp != nil {
 362			ptr1, err = graphql.UnmarshalString(tmp)
 363			arg1 = &ptr1
 364		}
 365
 366		if err != nil {
 367			return nil, err
 368		}
 369	}
 370	args["before"] = arg1
 371	var arg2 *int
 372	if tmp, ok := rawArgs["first"]; ok {
 373		var err error
 374		var ptr1 int
 375		if tmp != nil {
 376			ptr1, err = graphql.UnmarshalInt(tmp)
 377			arg2 = &ptr1
 378		}
 379
 380		if err != nil {
 381			return nil, err
 382		}
 383	}
 384	args["first"] = arg2
 385	var arg3 *int
 386	if tmp, ok := rawArgs["last"]; ok {
 387		var err error
 388		var ptr1 int
 389		if tmp != nil {
 390			ptr1, err = graphql.UnmarshalInt(tmp)
 391			arg3 = &ptr1
 392		}
 393
 394		if err != nil {
 395			return nil, err
 396		}
 397	}
 398	args["last"] = arg3
 399	return args, nil
 400
 401}
 402
 403func field_Bug_timeline_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
 404	args := map[string]interface{}{}
 405	var arg0 *string
 406	if tmp, ok := rawArgs["after"]; ok {
 407		var err error
 408		var ptr1 string
 409		if tmp != nil {
 410			ptr1, err = graphql.UnmarshalString(tmp)
 411			arg0 = &ptr1
 412		}
 413
 414		if err != nil {
 415			return nil, err
 416		}
 417	}
 418	args["after"] = arg0
 419	var arg1 *string
 420	if tmp, ok := rawArgs["before"]; ok {
 421		var err error
 422		var ptr1 string
 423		if tmp != nil {
 424			ptr1, err = graphql.UnmarshalString(tmp)
 425			arg1 = &ptr1
 426		}
 427
 428		if err != nil {
 429			return nil, err
 430		}
 431	}
 432	args["before"] = arg1
 433	var arg2 *int
 434	if tmp, ok := rawArgs["first"]; ok {
 435		var err error
 436		var ptr1 int
 437		if tmp != nil {
 438			ptr1, err = graphql.UnmarshalInt(tmp)
 439			arg2 = &ptr1
 440		}
 441
 442		if err != nil {
 443			return nil, err
 444		}
 445	}
 446	args["first"] = arg2
 447	var arg3 *int
 448	if tmp, ok := rawArgs["last"]; ok {
 449		var err error
 450		var ptr1 int
 451		if tmp != nil {
 452			ptr1, err = graphql.UnmarshalInt(tmp)
 453			arg3 = &ptr1
 454		}
 455
 456		if err != nil {
 457			return nil, err
 458		}
 459	}
 460	args["last"] = arg3
 461	return args, nil
 462
 463}
 464
 465func field_Bug_operations_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
 466	args := map[string]interface{}{}
 467	var arg0 *string
 468	if tmp, ok := rawArgs["after"]; ok {
 469		var err error
 470		var ptr1 string
 471		if tmp != nil {
 472			ptr1, err = graphql.UnmarshalString(tmp)
 473			arg0 = &ptr1
 474		}
 475
 476		if err != nil {
 477			return nil, err
 478		}
 479	}
 480	args["after"] = arg0
 481	var arg1 *string
 482	if tmp, ok := rawArgs["before"]; ok {
 483		var err error
 484		var ptr1 string
 485		if tmp != nil {
 486			ptr1, err = graphql.UnmarshalString(tmp)
 487			arg1 = &ptr1
 488		}
 489
 490		if err != nil {
 491			return nil, err
 492		}
 493	}
 494	args["before"] = arg1
 495	var arg2 *int
 496	if tmp, ok := rawArgs["first"]; ok {
 497		var err error
 498		var ptr1 int
 499		if tmp != nil {
 500			ptr1, err = graphql.UnmarshalInt(tmp)
 501			arg2 = &ptr1
 502		}
 503
 504		if err != nil {
 505			return nil, err
 506		}
 507	}
 508	args["first"] = arg2
 509	var arg3 *int
 510	if tmp, ok := rawArgs["last"]; ok {
 511		var err error
 512		var ptr1 int
 513		if tmp != nil {
 514			ptr1, err = graphql.UnmarshalInt(tmp)
 515			arg3 = &ptr1
 516		}
 517
 518		if err != nil {
 519			return nil, err
 520		}
 521	}
 522	args["last"] = arg3
 523	return args, nil
 524
 525}
 526
 527func field_Mutation_newBug_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
 528	args := map[string]interface{}{}
 529	var arg0 *string
 530	if tmp, ok := rawArgs["repoRef"]; ok {
 531		var err error
 532		var ptr1 string
 533		if tmp != nil {
 534			ptr1, err = graphql.UnmarshalString(tmp)
 535			arg0 = &ptr1
 536		}
 537
 538		if err != nil {
 539			return nil, err
 540		}
 541	}
 542	args["repoRef"] = arg0
 543	var arg1 string
 544	if tmp, ok := rawArgs["title"]; ok {
 545		var err error
 546		arg1, err = graphql.UnmarshalString(tmp)
 547		if err != nil {
 548			return nil, err
 549		}
 550	}
 551	args["title"] = arg1
 552	var arg2 string
 553	if tmp, ok := rawArgs["message"]; ok {
 554		var err error
 555		arg2, err = graphql.UnmarshalString(tmp)
 556		if err != nil {
 557			return nil, err
 558		}
 559	}
 560	args["message"] = arg2
 561	var arg3 []git.Hash
 562	if tmp, ok := rawArgs["files"]; ok {
 563		var err error
 564		var rawIf1 []interface{}
 565		if tmp != nil {
 566			if tmp1, ok := tmp.([]interface{}); ok {
 567				rawIf1 = tmp1
 568			} else {
 569				rawIf1 = []interface{}{tmp}
 570			}
 571		}
 572		arg3 = make([]git.Hash, len(rawIf1))
 573		for idx1 := range rawIf1 {
 574			err = (&arg3[idx1]).UnmarshalGQL(rawIf1[idx1])
 575		}
 576		if err != nil {
 577			return nil, err
 578		}
 579	}
 580	args["files"] = arg3
 581	return args, nil
 582
 583}
 584
 585func field_Mutation_addComment_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
 586	args := map[string]interface{}{}
 587	var arg0 *string
 588	if tmp, ok := rawArgs["repoRef"]; ok {
 589		var err error
 590		var ptr1 string
 591		if tmp != nil {
 592			ptr1, err = graphql.UnmarshalString(tmp)
 593			arg0 = &ptr1
 594		}
 595
 596		if err != nil {
 597			return nil, err
 598		}
 599	}
 600	args["repoRef"] = arg0
 601	var arg1 string
 602	if tmp, ok := rawArgs["prefix"]; ok {
 603		var err error
 604		arg1, err = graphql.UnmarshalString(tmp)
 605		if err != nil {
 606			return nil, err
 607		}
 608	}
 609	args["prefix"] = arg1
 610	var arg2 string
 611	if tmp, ok := rawArgs["message"]; ok {
 612		var err error
 613		arg2, err = graphql.UnmarshalString(tmp)
 614		if err != nil {
 615			return nil, err
 616		}
 617	}
 618	args["message"] = arg2
 619	var arg3 []git.Hash
 620	if tmp, ok := rawArgs["files"]; ok {
 621		var err error
 622		var rawIf1 []interface{}
 623		if tmp != nil {
 624			if tmp1, ok := tmp.([]interface{}); ok {
 625				rawIf1 = tmp1
 626			} else {
 627				rawIf1 = []interface{}{tmp}
 628			}
 629		}
 630		arg3 = make([]git.Hash, len(rawIf1))
 631		for idx1 := range rawIf1 {
 632			err = (&arg3[idx1]).UnmarshalGQL(rawIf1[idx1])
 633		}
 634		if err != nil {
 635			return nil, err
 636		}
 637	}
 638	args["files"] = arg3
 639	return args, nil
 640
 641}
 642
 643func field_Mutation_changeLabels_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
 644	args := map[string]interface{}{}
 645	var arg0 *string
 646	if tmp, ok := rawArgs["repoRef"]; ok {
 647		var err error
 648		var ptr1 string
 649		if tmp != nil {
 650			ptr1, err = graphql.UnmarshalString(tmp)
 651			arg0 = &ptr1
 652		}
 653
 654		if err != nil {
 655			return nil, err
 656		}
 657	}
 658	args["repoRef"] = arg0
 659	var arg1 string
 660	if tmp, ok := rawArgs["prefix"]; ok {
 661		var err error
 662		arg1, err = graphql.UnmarshalString(tmp)
 663		if err != nil {
 664			return nil, err
 665		}
 666	}
 667	args["prefix"] = arg1
 668	var arg2 []string
 669	if tmp, ok := rawArgs["added"]; ok {
 670		var err error
 671		var rawIf1 []interface{}
 672		if tmp != nil {
 673			if tmp1, ok := tmp.([]interface{}); ok {
 674				rawIf1 = tmp1
 675			} else {
 676				rawIf1 = []interface{}{tmp}
 677			}
 678		}
 679		arg2 = make([]string, len(rawIf1))
 680		for idx1 := range rawIf1 {
 681			arg2[idx1], err = graphql.UnmarshalString(rawIf1[idx1])
 682		}
 683		if err != nil {
 684			return nil, err
 685		}
 686	}
 687	args["added"] = arg2
 688	var arg3 []string
 689	if tmp, ok := rawArgs["removed"]; ok {
 690		var err error
 691		var rawIf1 []interface{}
 692		if tmp != nil {
 693			if tmp1, ok := tmp.([]interface{}); ok {
 694				rawIf1 = tmp1
 695			} else {
 696				rawIf1 = []interface{}{tmp}
 697			}
 698		}
 699		arg3 = make([]string, len(rawIf1))
 700		for idx1 := range rawIf1 {
 701			arg3[idx1], err = graphql.UnmarshalString(rawIf1[idx1])
 702		}
 703		if err != nil {
 704			return nil, err
 705		}
 706	}
 707	args["removed"] = arg3
 708	return args, nil
 709
 710}
 711
 712func field_Mutation_open_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
 713	args := map[string]interface{}{}
 714	var arg0 *string
 715	if tmp, ok := rawArgs["repoRef"]; ok {
 716		var err error
 717		var ptr1 string
 718		if tmp != nil {
 719			ptr1, err = graphql.UnmarshalString(tmp)
 720			arg0 = &ptr1
 721		}
 722
 723		if err != nil {
 724			return nil, err
 725		}
 726	}
 727	args["repoRef"] = arg0
 728	var arg1 string
 729	if tmp, ok := rawArgs["prefix"]; ok {
 730		var err error
 731		arg1, err = graphql.UnmarshalString(tmp)
 732		if err != nil {
 733			return nil, err
 734		}
 735	}
 736	args["prefix"] = arg1
 737	return args, nil
 738
 739}
 740
 741func field_Mutation_close_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
 742	args := map[string]interface{}{}
 743	var arg0 *string
 744	if tmp, ok := rawArgs["repoRef"]; ok {
 745		var err error
 746		var ptr1 string
 747		if tmp != nil {
 748			ptr1, err = graphql.UnmarshalString(tmp)
 749			arg0 = &ptr1
 750		}
 751
 752		if err != nil {
 753			return nil, err
 754		}
 755	}
 756	args["repoRef"] = arg0
 757	var arg1 string
 758	if tmp, ok := rawArgs["prefix"]; ok {
 759		var err error
 760		arg1, err = graphql.UnmarshalString(tmp)
 761		if err != nil {
 762			return nil, err
 763		}
 764	}
 765	args["prefix"] = arg1
 766	return args, nil
 767
 768}
 769
 770func field_Mutation_setTitle_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
 771	args := map[string]interface{}{}
 772	var arg0 *string
 773	if tmp, ok := rawArgs["repoRef"]; ok {
 774		var err error
 775		var ptr1 string
 776		if tmp != nil {
 777			ptr1, err = graphql.UnmarshalString(tmp)
 778			arg0 = &ptr1
 779		}
 780
 781		if err != nil {
 782			return nil, err
 783		}
 784	}
 785	args["repoRef"] = arg0
 786	var arg1 string
 787	if tmp, ok := rawArgs["prefix"]; ok {
 788		var err error
 789		arg1, err = graphql.UnmarshalString(tmp)
 790		if err != nil {
 791			return nil, err
 792		}
 793	}
 794	args["prefix"] = arg1
 795	var arg2 string
 796	if tmp, ok := rawArgs["title"]; ok {
 797		var err error
 798		arg2, err = graphql.UnmarshalString(tmp)
 799		if err != nil {
 800			return nil, err
 801		}
 802	}
 803	args["title"] = arg2
 804	return args, nil
 805
 806}
 807
 808func field_Mutation_commit_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
 809	args := map[string]interface{}{}
 810	var arg0 *string
 811	if tmp, ok := rawArgs["repoRef"]; ok {
 812		var err error
 813		var ptr1 string
 814		if tmp != nil {
 815			ptr1, err = graphql.UnmarshalString(tmp)
 816			arg0 = &ptr1
 817		}
 818
 819		if err != nil {
 820			return nil, err
 821		}
 822	}
 823	args["repoRef"] = arg0
 824	var arg1 string
 825	if tmp, ok := rawArgs["prefix"]; ok {
 826		var err error
 827		arg1, err = graphql.UnmarshalString(tmp)
 828		if err != nil {
 829			return nil, err
 830		}
 831	}
 832	args["prefix"] = arg1
 833	return args, nil
 834
 835}
 836
 837func field_Query_repository_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
 838	args := map[string]interface{}{}
 839	var arg0 string
 840	if tmp, ok := rawArgs["id"]; ok {
 841		var err error
 842		arg0, err = graphql.UnmarshalString(tmp)
 843		if err != nil {
 844			return nil, err
 845		}
 846	}
 847	args["id"] = arg0
 848	return args, nil
 849
 850}
 851
 852func field_Query___type_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
 853	args := map[string]interface{}{}
 854	var arg0 string
 855	if tmp, ok := rawArgs["name"]; ok {
 856		var err error
 857		arg0, err = graphql.UnmarshalString(tmp)
 858		if err != nil {
 859			return nil, err
 860		}
 861	}
 862	args["name"] = arg0
 863	return args, nil
 864
 865}
 866
 867func field_Repository_allBugs_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
 868	args := map[string]interface{}{}
 869	var arg0 *string
 870	if tmp, ok := rawArgs["after"]; ok {
 871		var err error
 872		var ptr1 string
 873		if tmp != nil {
 874			ptr1, err = graphql.UnmarshalString(tmp)
 875			arg0 = &ptr1
 876		}
 877
 878		if err != nil {
 879			return nil, err
 880		}
 881	}
 882	args["after"] = arg0
 883	var arg1 *string
 884	if tmp, ok := rawArgs["before"]; ok {
 885		var err error
 886		var ptr1 string
 887		if tmp != nil {
 888			ptr1, err = graphql.UnmarshalString(tmp)
 889			arg1 = &ptr1
 890		}
 891
 892		if err != nil {
 893			return nil, err
 894		}
 895	}
 896	args["before"] = arg1
 897	var arg2 *int
 898	if tmp, ok := rawArgs["first"]; ok {
 899		var err error
 900		var ptr1 int
 901		if tmp != nil {
 902			ptr1, err = graphql.UnmarshalInt(tmp)
 903			arg2 = &ptr1
 904		}
 905
 906		if err != nil {
 907			return nil, err
 908		}
 909	}
 910	args["first"] = arg2
 911	var arg3 *int
 912	if tmp, ok := rawArgs["last"]; ok {
 913		var err error
 914		var ptr1 int
 915		if tmp != nil {
 916			ptr1, err = graphql.UnmarshalInt(tmp)
 917			arg3 = &ptr1
 918		}
 919
 920		if err != nil {
 921			return nil, err
 922		}
 923	}
 924	args["last"] = arg3
 925	var arg4 *string
 926	if tmp, ok := rawArgs["query"]; ok {
 927		var err error
 928		var ptr1 string
 929		if tmp != nil {
 930			ptr1, err = graphql.UnmarshalString(tmp)
 931			arg4 = &ptr1
 932		}
 933
 934		if err != nil {
 935			return nil, err
 936		}
 937	}
 938	args["query"] = arg4
 939	return args, nil
 940
 941}
 942
 943func field_Repository_bug_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
 944	args := map[string]interface{}{}
 945	var arg0 string
 946	if tmp, ok := rawArgs["prefix"]; ok {
 947		var err error
 948		arg0, err = graphql.UnmarshalString(tmp)
 949		if err != nil {
 950			return nil, err
 951		}
 952	}
 953	args["prefix"] = arg0
 954	return args, nil
 955
 956}
 957
 958func field___Type_fields_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
 959	args := map[string]interface{}{}
 960	var arg0 bool
 961	if tmp, ok := rawArgs["includeDeprecated"]; ok {
 962		var err error
 963		arg0, err = graphql.UnmarshalBoolean(tmp)
 964		if err != nil {
 965			return nil, err
 966		}
 967	}
 968	args["includeDeprecated"] = arg0
 969	return args, nil
 970
 971}
 972
 973func field___Type_enumValues_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
 974	args := map[string]interface{}{}
 975	var arg0 bool
 976	if tmp, ok := rawArgs["includeDeprecated"]; ok {
 977		var err error
 978		arg0, err = graphql.UnmarshalBoolean(tmp)
 979		if err != nil {
 980			return nil, err
 981		}
 982	}
 983	args["includeDeprecated"] = arg0
 984	return args, nil
 985
 986}
 987
 988type executableSchema struct {
 989	resolvers  ResolverRoot
 990	directives DirectiveRoot
 991	complexity ComplexityRoot
 992}
 993
 994func (e *executableSchema) Schema() *ast.Schema {
 995	return parsedSchema
 996}
 997
 998func (e *executableSchema) Complexity(typeName, field string, childComplexity int, rawArgs map[string]interface{}) (int, bool) {
 999	switch typeName + "." + field {
1000
1001	case "AddCommentOperation.hash":
1002		if e.complexity.AddCommentOperation.Hash == nil {
1003			break
1004		}
1005
1006		return e.complexity.AddCommentOperation.Hash(childComplexity), true
1007
1008	case "AddCommentOperation.author":
1009		if e.complexity.AddCommentOperation.Author == nil {
1010			break
1011		}
1012
1013		return e.complexity.AddCommentOperation.Author(childComplexity), true
1014
1015	case "AddCommentOperation.date":
1016		if e.complexity.AddCommentOperation.Date == nil {
1017			break
1018		}
1019
1020		return e.complexity.AddCommentOperation.Date(childComplexity), true
1021
1022	case "AddCommentOperation.message":
1023		if e.complexity.AddCommentOperation.Message == nil {
1024			break
1025		}
1026
1027		return e.complexity.AddCommentOperation.Message(childComplexity), true
1028
1029	case "AddCommentOperation.files":
1030		if e.complexity.AddCommentOperation.Files == nil {
1031			break
1032		}
1033
1034		return e.complexity.AddCommentOperation.Files(childComplexity), true
1035
1036	case "AddCommentTimelineItem.hash":
1037		if e.complexity.AddCommentTimelineItem.Hash == nil {
1038			break
1039		}
1040
1041		return e.complexity.AddCommentTimelineItem.Hash(childComplexity), true
1042
1043	case "AddCommentTimelineItem.author":
1044		if e.complexity.AddCommentTimelineItem.Author == nil {
1045			break
1046		}
1047
1048		return e.complexity.AddCommentTimelineItem.Author(childComplexity), true
1049
1050	case "AddCommentTimelineItem.message":
1051		if e.complexity.AddCommentTimelineItem.Message == nil {
1052			break
1053		}
1054
1055		return e.complexity.AddCommentTimelineItem.Message(childComplexity), true
1056
1057	case "AddCommentTimelineItem.messageIsEmpty":
1058		if e.complexity.AddCommentTimelineItem.MessageIsEmpty == nil {
1059			break
1060		}
1061
1062		return e.complexity.AddCommentTimelineItem.MessageIsEmpty(childComplexity), true
1063
1064	case "AddCommentTimelineItem.files":
1065		if e.complexity.AddCommentTimelineItem.Files == nil {
1066			break
1067		}
1068
1069		return e.complexity.AddCommentTimelineItem.Files(childComplexity), true
1070
1071	case "AddCommentTimelineItem.createdAt":
1072		if e.complexity.AddCommentTimelineItem.CreatedAt == nil {
1073			break
1074		}
1075
1076		return e.complexity.AddCommentTimelineItem.CreatedAt(childComplexity), true
1077
1078	case "AddCommentTimelineItem.lastEdit":
1079		if e.complexity.AddCommentTimelineItem.LastEdit == nil {
1080			break
1081		}
1082
1083		return e.complexity.AddCommentTimelineItem.LastEdit(childComplexity), true
1084
1085	case "AddCommentTimelineItem.edited":
1086		if e.complexity.AddCommentTimelineItem.Edited == nil {
1087			break
1088		}
1089
1090		return e.complexity.AddCommentTimelineItem.Edited(childComplexity), true
1091
1092	case "AddCommentTimelineItem.history":
1093		if e.complexity.AddCommentTimelineItem.History == nil {
1094			break
1095		}
1096
1097		return e.complexity.AddCommentTimelineItem.History(childComplexity), true
1098
1099	case "Bug.id":
1100		if e.complexity.Bug.Id == nil {
1101			break
1102		}
1103
1104		return e.complexity.Bug.Id(childComplexity), true
1105
1106	case "Bug.humanId":
1107		if e.complexity.Bug.HumanId == nil {
1108			break
1109		}
1110
1111		return e.complexity.Bug.HumanId(childComplexity), true
1112
1113	case "Bug.status":
1114		if e.complexity.Bug.Status == nil {
1115			break
1116		}
1117
1118		return e.complexity.Bug.Status(childComplexity), true
1119
1120	case "Bug.title":
1121		if e.complexity.Bug.Title == nil {
1122			break
1123		}
1124
1125		return e.complexity.Bug.Title(childComplexity), true
1126
1127	case "Bug.labels":
1128		if e.complexity.Bug.Labels == nil {
1129			break
1130		}
1131
1132		return e.complexity.Bug.Labels(childComplexity), true
1133
1134	case "Bug.author":
1135		if e.complexity.Bug.Author == nil {
1136			break
1137		}
1138
1139		return e.complexity.Bug.Author(childComplexity), true
1140
1141	case "Bug.createdAt":
1142		if e.complexity.Bug.CreatedAt == nil {
1143			break
1144		}
1145
1146		return e.complexity.Bug.CreatedAt(childComplexity), true
1147
1148	case "Bug.lastEdit":
1149		if e.complexity.Bug.LastEdit == nil {
1150			break
1151		}
1152
1153		return e.complexity.Bug.LastEdit(childComplexity), true
1154
1155	case "Bug.comments":
1156		if e.complexity.Bug.Comments == nil {
1157			break
1158		}
1159
1160		args, err := field_Bug_comments_args(rawArgs)
1161		if err != nil {
1162			return 0, false
1163		}
1164
1165		return e.complexity.Bug.Comments(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
1166
1167	case "Bug.timeline":
1168		if e.complexity.Bug.Timeline == nil {
1169			break
1170		}
1171
1172		args, err := field_Bug_timeline_args(rawArgs)
1173		if err != nil {
1174			return 0, false
1175		}
1176
1177		return e.complexity.Bug.Timeline(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
1178
1179	case "Bug.operations":
1180		if e.complexity.Bug.Operations == nil {
1181			break
1182		}
1183
1184		args, err := field_Bug_operations_args(rawArgs)
1185		if err != nil {
1186			return 0, false
1187		}
1188
1189		return e.complexity.Bug.Operations(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
1190
1191	case "BugConnection.edges":
1192		if e.complexity.BugConnection.Edges == nil {
1193			break
1194		}
1195
1196		return e.complexity.BugConnection.Edges(childComplexity), true
1197
1198	case "BugConnection.nodes":
1199		if e.complexity.BugConnection.Nodes == nil {
1200			break
1201		}
1202
1203		return e.complexity.BugConnection.Nodes(childComplexity), true
1204
1205	case "BugConnection.pageInfo":
1206		if e.complexity.BugConnection.PageInfo == nil {
1207			break
1208		}
1209
1210		return e.complexity.BugConnection.PageInfo(childComplexity), true
1211
1212	case "BugConnection.totalCount":
1213		if e.complexity.BugConnection.TotalCount == nil {
1214			break
1215		}
1216
1217		return e.complexity.BugConnection.TotalCount(childComplexity), true
1218
1219	case "BugEdge.cursor":
1220		if e.complexity.BugEdge.Cursor == nil {
1221			break
1222		}
1223
1224		return e.complexity.BugEdge.Cursor(childComplexity), true
1225
1226	case "BugEdge.node":
1227		if e.complexity.BugEdge.Node == nil {
1228			break
1229		}
1230
1231		return e.complexity.BugEdge.Node(childComplexity), true
1232
1233	case "Comment.author":
1234		if e.complexity.Comment.Author == nil {
1235			break
1236		}
1237
1238		return e.complexity.Comment.Author(childComplexity), true
1239
1240	case "Comment.message":
1241		if e.complexity.Comment.Message == nil {
1242			break
1243		}
1244
1245		return e.complexity.Comment.Message(childComplexity), true
1246
1247	case "Comment.files":
1248		if e.complexity.Comment.Files == nil {
1249			break
1250		}
1251
1252		return e.complexity.Comment.Files(childComplexity), true
1253
1254	case "CommentConnection.edges":
1255		if e.complexity.CommentConnection.Edges == nil {
1256			break
1257		}
1258
1259		return e.complexity.CommentConnection.Edges(childComplexity), true
1260
1261	case "CommentConnection.nodes":
1262		if e.complexity.CommentConnection.Nodes == nil {
1263			break
1264		}
1265
1266		return e.complexity.CommentConnection.Nodes(childComplexity), true
1267
1268	case "CommentConnection.pageInfo":
1269		if e.complexity.CommentConnection.PageInfo == nil {
1270			break
1271		}
1272
1273		return e.complexity.CommentConnection.PageInfo(childComplexity), true
1274
1275	case "CommentConnection.totalCount":
1276		if e.complexity.CommentConnection.TotalCount == nil {
1277			break
1278		}
1279
1280		return e.complexity.CommentConnection.TotalCount(childComplexity), true
1281
1282	case "CommentEdge.cursor":
1283		if e.complexity.CommentEdge.Cursor == nil {
1284			break
1285		}
1286
1287		return e.complexity.CommentEdge.Cursor(childComplexity), true
1288
1289	case "CommentEdge.node":
1290		if e.complexity.CommentEdge.Node == nil {
1291			break
1292		}
1293
1294		return e.complexity.CommentEdge.Node(childComplexity), true
1295
1296	case "CommentHistoryStep.message":
1297		if e.complexity.CommentHistoryStep.Message == nil {
1298			break
1299		}
1300
1301		return e.complexity.CommentHistoryStep.Message(childComplexity), true
1302
1303	case "CommentHistoryStep.date":
1304		if e.complexity.CommentHistoryStep.Date == nil {
1305			break
1306		}
1307
1308		return e.complexity.CommentHistoryStep.Date(childComplexity), true
1309
1310	case "CreateOperation.hash":
1311		if e.complexity.CreateOperation.Hash == nil {
1312			break
1313		}
1314
1315		return e.complexity.CreateOperation.Hash(childComplexity), true
1316
1317	case "CreateOperation.author":
1318		if e.complexity.CreateOperation.Author == nil {
1319			break
1320		}
1321
1322		return e.complexity.CreateOperation.Author(childComplexity), true
1323
1324	case "CreateOperation.date":
1325		if e.complexity.CreateOperation.Date == nil {
1326			break
1327		}
1328
1329		return e.complexity.CreateOperation.Date(childComplexity), true
1330
1331	case "CreateOperation.title":
1332		if e.complexity.CreateOperation.Title == nil {
1333			break
1334		}
1335
1336		return e.complexity.CreateOperation.Title(childComplexity), true
1337
1338	case "CreateOperation.message":
1339		if e.complexity.CreateOperation.Message == nil {
1340			break
1341		}
1342
1343		return e.complexity.CreateOperation.Message(childComplexity), true
1344
1345	case "CreateOperation.files":
1346		if e.complexity.CreateOperation.Files == nil {
1347			break
1348		}
1349
1350		return e.complexity.CreateOperation.Files(childComplexity), true
1351
1352	case "CreateTimelineItem.hash":
1353		if e.complexity.CreateTimelineItem.Hash == nil {
1354			break
1355		}
1356
1357		return e.complexity.CreateTimelineItem.Hash(childComplexity), true
1358
1359	case "CreateTimelineItem.author":
1360		if e.complexity.CreateTimelineItem.Author == nil {
1361			break
1362		}
1363
1364		return e.complexity.CreateTimelineItem.Author(childComplexity), true
1365
1366	case "CreateTimelineItem.message":
1367		if e.complexity.CreateTimelineItem.Message == nil {
1368			break
1369		}
1370
1371		return e.complexity.CreateTimelineItem.Message(childComplexity), true
1372
1373	case "CreateTimelineItem.messageIsEmpty":
1374		if e.complexity.CreateTimelineItem.MessageIsEmpty == nil {
1375			break
1376		}
1377
1378		return e.complexity.CreateTimelineItem.MessageIsEmpty(childComplexity), true
1379
1380	case "CreateTimelineItem.files":
1381		if e.complexity.CreateTimelineItem.Files == nil {
1382			break
1383		}
1384
1385		return e.complexity.CreateTimelineItem.Files(childComplexity), true
1386
1387	case "CreateTimelineItem.createdAt":
1388		if e.complexity.CreateTimelineItem.CreatedAt == nil {
1389			break
1390		}
1391
1392		return e.complexity.CreateTimelineItem.CreatedAt(childComplexity), true
1393
1394	case "CreateTimelineItem.lastEdit":
1395		if e.complexity.CreateTimelineItem.LastEdit == nil {
1396			break
1397		}
1398
1399		return e.complexity.CreateTimelineItem.LastEdit(childComplexity), true
1400
1401	case "CreateTimelineItem.edited":
1402		if e.complexity.CreateTimelineItem.Edited == nil {
1403			break
1404		}
1405
1406		return e.complexity.CreateTimelineItem.Edited(childComplexity), true
1407
1408	case "CreateTimelineItem.history":
1409		if e.complexity.CreateTimelineItem.History == nil {
1410			break
1411		}
1412
1413		return e.complexity.CreateTimelineItem.History(childComplexity), true
1414
1415	case "EditCommentOperation.hash":
1416		if e.complexity.EditCommentOperation.Hash == nil {
1417			break
1418		}
1419
1420		return e.complexity.EditCommentOperation.Hash(childComplexity), true
1421
1422	case "EditCommentOperation.author":
1423		if e.complexity.EditCommentOperation.Author == nil {
1424			break
1425		}
1426
1427		return e.complexity.EditCommentOperation.Author(childComplexity), true
1428
1429	case "EditCommentOperation.date":
1430		if e.complexity.EditCommentOperation.Date == nil {
1431			break
1432		}
1433
1434		return e.complexity.EditCommentOperation.Date(childComplexity), true
1435
1436	case "EditCommentOperation.target":
1437		if e.complexity.EditCommentOperation.Target == nil {
1438			break
1439		}
1440
1441		return e.complexity.EditCommentOperation.Target(childComplexity), true
1442
1443	case "EditCommentOperation.message":
1444		if e.complexity.EditCommentOperation.Message == nil {
1445			break
1446		}
1447
1448		return e.complexity.EditCommentOperation.Message(childComplexity), true
1449
1450	case "EditCommentOperation.files":
1451		if e.complexity.EditCommentOperation.Files == nil {
1452			break
1453		}
1454
1455		return e.complexity.EditCommentOperation.Files(childComplexity), true
1456
1457	case "Identity.name":
1458		if e.complexity.Identity.Name == nil {
1459			break
1460		}
1461
1462		return e.complexity.Identity.Name(childComplexity), true
1463
1464	case "Identity.email":
1465		if e.complexity.Identity.Email == nil {
1466			break
1467		}
1468
1469		return e.complexity.Identity.Email(childComplexity), true
1470
1471	case "Identity.login":
1472		if e.complexity.Identity.Login == nil {
1473			break
1474		}
1475
1476		return e.complexity.Identity.Login(childComplexity), true
1477
1478	case "Identity.displayName":
1479		if e.complexity.Identity.DisplayName == nil {
1480			break
1481		}
1482
1483		return e.complexity.Identity.DisplayName(childComplexity), true
1484
1485	case "Identity.avatarUrl":
1486		if e.complexity.Identity.AvatarUrl == nil {
1487			break
1488		}
1489
1490		return e.complexity.Identity.AvatarUrl(childComplexity), true
1491
1492	case "LabelChangeOperation.hash":
1493		if e.complexity.LabelChangeOperation.Hash == nil {
1494			break
1495		}
1496
1497		return e.complexity.LabelChangeOperation.Hash(childComplexity), true
1498
1499	case "LabelChangeOperation.author":
1500		if e.complexity.LabelChangeOperation.Author == nil {
1501			break
1502		}
1503
1504		return e.complexity.LabelChangeOperation.Author(childComplexity), true
1505
1506	case "LabelChangeOperation.date":
1507		if e.complexity.LabelChangeOperation.Date == nil {
1508			break
1509		}
1510
1511		return e.complexity.LabelChangeOperation.Date(childComplexity), true
1512
1513	case "LabelChangeOperation.added":
1514		if e.complexity.LabelChangeOperation.Added == nil {
1515			break
1516		}
1517
1518		return e.complexity.LabelChangeOperation.Added(childComplexity), true
1519
1520	case "LabelChangeOperation.removed":
1521		if e.complexity.LabelChangeOperation.Removed == nil {
1522			break
1523		}
1524
1525		return e.complexity.LabelChangeOperation.Removed(childComplexity), true
1526
1527	case "LabelChangeTimelineItem.hash":
1528		if e.complexity.LabelChangeTimelineItem.Hash == nil {
1529			break
1530		}
1531
1532		return e.complexity.LabelChangeTimelineItem.Hash(childComplexity), true
1533
1534	case "LabelChangeTimelineItem.author":
1535		if e.complexity.LabelChangeTimelineItem.Author == nil {
1536			break
1537		}
1538
1539		return e.complexity.LabelChangeTimelineItem.Author(childComplexity), true
1540
1541	case "LabelChangeTimelineItem.date":
1542		if e.complexity.LabelChangeTimelineItem.Date == nil {
1543			break
1544		}
1545
1546		return e.complexity.LabelChangeTimelineItem.Date(childComplexity), true
1547
1548	case "LabelChangeTimelineItem.added":
1549		if e.complexity.LabelChangeTimelineItem.Added == nil {
1550			break
1551		}
1552
1553		return e.complexity.LabelChangeTimelineItem.Added(childComplexity), true
1554
1555	case "LabelChangeTimelineItem.removed":
1556		if e.complexity.LabelChangeTimelineItem.Removed == nil {
1557			break
1558		}
1559
1560		return e.complexity.LabelChangeTimelineItem.Removed(childComplexity), true
1561
1562	case "Mutation.newBug":
1563		if e.complexity.Mutation.NewBug == nil {
1564			break
1565		}
1566
1567		args, err := field_Mutation_newBug_args(rawArgs)
1568		if err != nil {
1569			return 0, false
1570		}
1571
1572		return e.complexity.Mutation.NewBug(childComplexity, args["repoRef"].(*string), args["title"].(string), args["message"].(string), args["files"].([]git.Hash)), true
1573
1574	case "Mutation.addComment":
1575		if e.complexity.Mutation.AddComment == nil {
1576			break
1577		}
1578
1579		args, err := field_Mutation_addComment_args(rawArgs)
1580		if err != nil {
1581			return 0, false
1582		}
1583
1584		return e.complexity.Mutation.AddComment(childComplexity, args["repoRef"].(*string), args["prefix"].(string), args["message"].(string), args["files"].([]git.Hash)), true
1585
1586	case "Mutation.changeLabels":
1587		if e.complexity.Mutation.ChangeLabels == nil {
1588			break
1589		}
1590
1591		args, err := field_Mutation_changeLabels_args(rawArgs)
1592		if err != nil {
1593			return 0, false
1594		}
1595
1596		return e.complexity.Mutation.ChangeLabels(childComplexity, args["repoRef"].(*string), args["prefix"].(string), args["added"].([]string), args["removed"].([]string)), true
1597
1598	case "Mutation.open":
1599		if e.complexity.Mutation.Open == nil {
1600			break
1601		}
1602
1603		args, err := field_Mutation_open_args(rawArgs)
1604		if err != nil {
1605			return 0, false
1606		}
1607
1608		return e.complexity.Mutation.Open(childComplexity, args["repoRef"].(*string), args["prefix"].(string)), true
1609
1610	case "Mutation.close":
1611		if e.complexity.Mutation.Close == nil {
1612			break
1613		}
1614
1615		args, err := field_Mutation_close_args(rawArgs)
1616		if err != nil {
1617			return 0, false
1618		}
1619
1620		return e.complexity.Mutation.Close(childComplexity, args["repoRef"].(*string), args["prefix"].(string)), true
1621
1622	case "Mutation.setTitle":
1623		if e.complexity.Mutation.SetTitle == nil {
1624			break
1625		}
1626
1627		args, err := field_Mutation_setTitle_args(rawArgs)
1628		if err != nil {
1629			return 0, false
1630		}
1631
1632		return e.complexity.Mutation.SetTitle(childComplexity, args["repoRef"].(*string), args["prefix"].(string), args["title"].(string)), true
1633
1634	case "Mutation.commit":
1635		if e.complexity.Mutation.Commit == nil {
1636			break
1637		}
1638
1639		args, err := field_Mutation_commit_args(rawArgs)
1640		if err != nil {
1641			return 0, false
1642		}
1643
1644		return e.complexity.Mutation.Commit(childComplexity, args["repoRef"].(*string), args["prefix"].(string)), true
1645
1646	case "OperationConnection.edges":
1647		if e.complexity.OperationConnection.Edges == nil {
1648			break
1649		}
1650
1651		return e.complexity.OperationConnection.Edges(childComplexity), true
1652
1653	case "OperationConnection.nodes":
1654		if e.complexity.OperationConnection.Nodes == nil {
1655			break
1656		}
1657
1658		return e.complexity.OperationConnection.Nodes(childComplexity), true
1659
1660	case "OperationConnection.pageInfo":
1661		if e.complexity.OperationConnection.PageInfo == nil {
1662			break
1663		}
1664
1665		return e.complexity.OperationConnection.PageInfo(childComplexity), true
1666
1667	case "OperationConnection.totalCount":
1668		if e.complexity.OperationConnection.TotalCount == nil {
1669			break
1670		}
1671
1672		return e.complexity.OperationConnection.TotalCount(childComplexity), true
1673
1674	case "OperationEdge.cursor":
1675		if e.complexity.OperationEdge.Cursor == nil {
1676			break
1677		}
1678
1679		return e.complexity.OperationEdge.Cursor(childComplexity), true
1680
1681	case "OperationEdge.node":
1682		if e.complexity.OperationEdge.Node == nil {
1683			break
1684		}
1685
1686		return e.complexity.OperationEdge.Node(childComplexity), true
1687
1688	case "PageInfo.hasNextPage":
1689		if e.complexity.PageInfo.HasNextPage == nil {
1690			break
1691		}
1692
1693		return e.complexity.PageInfo.HasNextPage(childComplexity), true
1694
1695	case "PageInfo.hasPreviousPage":
1696		if e.complexity.PageInfo.HasPreviousPage == nil {
1697			break
1698		}
1699
1700		return e.complexity.PageInfo.HasPreviousPage(childComplexity), true
1701
1702	case "PageInfo.startCursor":
1703		if e.complexity.PageInfo.StartCursor == nil {
1704			break
1705		}
1706
1707		return e.complexity.PageInfo.StartCursor(childComplexity), true
1708
1709	case "PageInfo.endCursor":
1710		if e.complexity.PageInfo.EndCursor == nil {
1711			break
1712		}
1713
1714		return e.complexity.PageInfo.EndCursor(childComplexity), true
1715
1716	case "Query.defaultRepository":
1717		if e.complexity.Query.DefaultRepository == nil {
1718			break
1719		}
1720
1721		return e.complexity.Query.DefaultRepository(childComplexity), true
1722
1723	case "Query.repository":
1724		if e.complexity.Query.Repository == nil {
1725			break
1726		}
1727
1728		args, err := field_Query_repository_args(rawArgs)
1729		if err != nil {
1730			return 0, false
1731		}
1732
1733		return e.complexity.Query.Repository(childComplexity, args["id"].(string)), true
1734
1735	case "Repository.allBugs":
1736		if e.complexity.Repository.AllBugs == nil {
1737			break
1738		}
1739
1740		args, err := field_Repository_allBugs_args(rawArgs)
1741		if err != nil {
1742			return 0, false
1743		}
1744
1745		return e.complexity.Repository.AllBugs(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int), args["query"].(*string)), true
1746
1747	case "Repository.bug":
1748		if e.complexity.Repository.Bug == nil {
1749			break
1750		}
1751
1752		args, err := field_Repository_bug_args(rawArgs)
1753		if err != nil {
1754			return 0, false
1755		}
1756
1757		return e.complexity.Repository.Bug(childComplexity, args["prefix"].(string)), true
1758
1759	case "SetStatusOperation.hash":
1760		if e.complexity.SetStatusOperation.Hash == nil {
1761			break
1762		}
1763
1764		return e.complexity.SetStatusOperation.Hash(childComplexity), true
1765
1766	case "SetStatusOperation.author":
1767		if e.complexity.SetStatusOperation.Author == nil {
1768			break
1769		}
1770
1771		return e.complexity.SetStatusOperation.Author(childComplexity), true
1772
1773	case "SetStatusOperation.date":
1774		if e.complexity.SetStatusOperation.Date == nil {
1775			break
1776		}
1777
1778		return e.complexity.SetStatusOperation.Date(childComplexity), true
1779
1780	case "SetStatusOperation.status":
1781		if e.complexity.SetStatusOperation.Status == nil {
1782			break
1783		}
1784
1785		return e.complexity.SetStatusOperation.Status(childComplexity), true
1786
1787	case "SetStatusTimelineItem.hash":
1788		if e.complexity.SetStatusTimelineItem.Hash == nil {
1789			break
1790		}
1791
1792		return e.complexity.SetStatusTimelineItem.Hash(childComplexity), true
1793
1794	case "SetStatusTimelineItem.author":
1795		if e.complexity.SetStatusTimelineItem.Author == nil {
1796			break
1797		}
1798
1799		return e.complexity.SetStatusTimelineItem.Author(childComplexity), true
1800
1801	case "SetStatusTimelineItem.date":
1802		if e.complexity.SetStatusTimelineItem.Date == nil {
1803			break
1804		}
1805
1806		return e.complexity.SetStatusTimelineItem.Date(childComplexity), true
1807
1808	case "SetStatusTimelineItem.status":
1809		if e.complexity.SetStatusTimelineItem.Status == nil {
1810			break
1811		}
1812
1813		return e.complexity.SetStatusTimelineItem.Status(childComplexity), true
1814
1815	case "SetTitleOperation.hash":
1816		if e.complexity.SetTitleOperation.Hash == nil {
1817			break
1818		}
1819
1820		return e.complexity.SetTitleOperation.Hash(childComplexity), true
1821
1822	case "SetTitleOperation.author":
1823		if e.complexity.SetTitleOperation.Author == nil {
1824			break
1825		}
1826
1827		return e.complexity.SetTitleOperation.Author(childComplexity), true
1828
1829	case "SetTitleOperation.date":
1830		if e.complexity.SetTitleOperation.Date == nil {
1831			break
1832		}
1833
1834		return e.complexity.SetTitleOperation.Date(childComplexity), true
1835
1836	case "SetTitleOperation.title":
1837		if e.complexity.SetTitleOperation.Title == nil {
1838			break
1839		}
1840
1841		return e.complexity.SetTitleOperation.Title(childComplexity), true
1842
1843	case "SetTitleOperation.was":
1844		if e.complexity.SetTitleOperation.Was == nil {
1845			break
1846		}
1847
1848		return e.complexity.SetTitleOperation.Was(childComplexity), true
1849
1850	case "SetTitleTimelineItem.hash":
1851		if e.complexity.SetTitleTimelineItem.Hash == nil {
1852			break
1853		}
1854
1855		return e.complexity.SetTitleTimelineItem.Hash(childComplexity), true
1856
1857	case "SetTitleTimelineItem.author":
1858		if e.complexity.SetTitleTimelineItem.Author == nil {
1859			break
1860		}
1861
1862		return e.complexity.SetTitleTimelineItem.Author(childComplexity), true
1863
1864	case "SetTitleTimelineItem.date":
1865		if e.complexity.SetTitleTimelineItem.Date == nil {
1866			break
1867		}
1868
1869		return e.complexity.SetTitleTimelineItem.Date(childComplexity), true
1870
1871	case "SetTitleTimelineItem.title":
1872		if e.complexity.SetTitleTimelineItem.Title == nil {
1873			break
1874		}
1875
1876		return e.complexity.SetTitleTimelineItem.Title(childComplexity), true
1877
1878	case "SetTitleTimelineItem.was":
1879		if e.complexity.SetTitleTimelineItem.Was == nil {
1880			break
1881		}
1882
1883		return e.complexity.SetTitleTimelineItem.Was(childComplexity), true
1884
1885	case "TimelineItemConnection.edges":
1886		if e.complexity.TimelineItemConnection.Edges == nil {
1887			break
1888		}
1889
1890		return e.complexity.TimelineItemConnection.Edges(childComplexity), true
1891
1892	case "TimelineItemConnection.nodes":
1893		if e.complexity.TimelineItemConnection.Nodes == nil {
1894			break
1895		}
1896
1897		return e.complexity.TimelineItemConnection.Nodes(childComplexity), true
1898
1899	case "TimelineItemConnection.pageInfo":
1900		if e.complexity.TimelineItemConnection.PageInfo == nil {
1901			break
1902		}
1903
1904		return e.complexity.TimelineItemConnection.PageInfo(childComplexity), true
1905
1906	case "TimelineItemConnection.totalCount":
1907		if e.complexity.TimelineItemConnection.TotalCount == nil {
1908			break
1909		}
1910
1911		return e.complexity.TimelineItemConnection.TotalCount(childComplexity), true
1912
1913	case "TimelineItemEdge.cursor":
1914		if e.complexity.TimelineItemEdge.Cursor == nil {
1915			break
1916		}
1917
1918		return e.complexity.TimelineItemEdge.Cursor(childComplexity), true
1919
1920	case "TimelineItemEdge.node":
1921		if e.complexity.TimelineItemEdge.Node == nil {
1922			break
1923		}
1924
1925		return e.complexity.TimelineItemEdge.Node(childComplexity), true
1926
1927	}
1928	return 0, false
1929}
1930
1931func (e *executableSchema) Query(ctx context.Context, op *ast.OperationDefinition) *graphql.Response {
1932	ec := executionContext{graphql.GetRequestContext(ctx), e}
1933
1934	buf := ec.RequestMiddleware(ctx, func(ctx context.Context) []byte {
1935		data := ec._Query(ctx, op.SelectionSet)
1936		var buf bytes.Buffer
1937		data.MarshalGQL(&buf)
1938		return buf.Bytes()
1939	})
1940
1941	return &graphql.Response{
1942		Data:       buf,
1943		Errors:     ec.Errors,
1944		Extensions: ec.Extensions}
1945}
1946
1947func (e *executableSchema) Mutation(ctx context.Context, op *ast.OperationDefinition) *graphql.Response {
1948	ec := executionContext{graphql.GetRequestContext(ctx), e}
1949
1950	buf := ec.RequestMiddleware(ctx, func(ctx context.Context) []byte {
1951		data := ec._Mutation(ctx, op.SelectionSet)
1952		var buf bytes.Buffer
1953		data.MarshalGQL(&buf)
1954		return buf.Bytes()
1955	})
1956
1957	return &graphql.Response{
1958		Data:       buf,
1959		Errors:     ec.Errors,
1960		Extensions: ec.Extensions,
1961	}
1962}
1963
1964func (e *executableSchema) Subscription(ctx context.Context, op *ast.OperationDefinition) func() *graphql.Response {
1965	return graphql.OneShot(graphql.ErrorResponse(ctx, "subscriptions are not supported"))
1966}
1967
1968type executionContext struct {
1969	*graphql.RequestContext
1970	*executableSchema
1971}
1972
1973var addCommentOperationImplementors = []string{"AddCommentOperation", "Operation", "Authored"}
1974
1975// nolint: gocyclo, errcheck, gas, goconst
1976func (ec *executionContext) _AddCommentOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.AddCommentOperation) graphql.Marshaler {
1977	fields := graphql.CollectFields(ctx, sel, addCommentOperationImplementors)
1978
1979	var wg sync.WaitGroup
1980	out := graphql.NewOrderedMap(len(fields))
1981	invalid := false
1982	for i, field := range fields {
1983		out.Keys[i] = field.Alias
1984
1985		switch field.Name {
1986		case "__typename":
1987			out.Values[i] = graphql.MarshalString("AddCommentOperation")
1988		case "hash":
1989			out.Values[i] = ec._AddCommentOperation_hash(ctx, field, obj)
1990			if out.Values[i] == graphql.Null {
1991				invalid = true
1992			}
1993		case "author":
1994			out.Values[i] = ec._AddCommentOperation_author(ctx, field, obj)
1995			if out.Values[i] == graphql.Null {
1996				invalid = true
1997			}
1998		case "date":
1999			wg.Add(1)
2000			go func(i int, field graphql.CollectedField) {
2001				out.Values[i] = ec._AddCommentOperation_date(ctx, field, obj)
2002				if out.Values[i] == graphql.Null {
2003					invalid = true
2004				}
2005				wg.Done()
2006			}(i, field)
2007		case "message":
2008			out.Values[i] = ec._AddCommentOperation_message(ctx, field, obj)
2009			if out.Values[i] == graphql.Null {
2010				invalid = true
2011			}
2012		case "files":
2013			out.Values[i] = ec._AddCommentOperation_files(ctx, field, obj)
2014			if out.Values[i] == graphql.Null {
2015				invalid = true
2016			}
2017		default:
2018			panic("unknown field " + strconv.Quote(field.Name))
2019		}
2020	}
2021	wg.Wait()
2022	if invalid {
2023		return graphql.Null
2024	}
2025	return out
2026}
2027
2028// nolint: vetshadow
2029func (ec *executionContext) _AddCommentOperation_hash(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) graphql.Marshaler {
2030	ctx = ec.Tracer.StartFieldExecution(ctx, field)
2031	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2032	rctx := &graphql.ResolverContext{
2033		Object: "AddCommentOperation",
2034		Args:   nil,
2035		Field:  field,
2036	}
2037	ctx = graphql.WithResolverContext(ctx, rctx)
2038	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2039	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2040		ctx = rctx // use context from middleware stack in children
2041		return obj.Hash()
2042	})
2043	if resTmp == nil {
2044		if !ec.HasError(rctx) {
2045			ec.Errorf(ctx, "must not be null")
2046		}
2047		return graphql.Null
2048	}
2049	res := resTmp.(git.Hash)
2050	rctx.Result = res
2051	ctx = ec.Tracer.StartFieldChildExecution(ctx)
2052	return res
2053}
2054
2055// nolint: vetshadow
2056func (ec *executionContext) _AddCommentOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) graphql.Marshaler {
2057	ctx = ec.Tracer.StartFieldExecution(ctx, field)
2058	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2059	rctx := &graphql.ResolverContext{
2060		Object: "AddCommentOperation",
2061		Args:   nil,
2062		Field:  field,
2063	}
2064	ctx = graphql.WithResolverContext(ctx, rctx)
2065	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2066	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2067		ctx = rctx // use context from middleware stack in children
2068		return obj.Author, nil
2069	})
2070	if resTmp == nil {
2071		if !ec.HasError(rctx) {
2072			ec.Errorf(ctx, "must not be null")
2073		}
2074		return graphql.Null
2075	}
2076	res := resTmp.(identity.Interface)
2077	rctx.Result = res
2078	ctx = ec.Tracer.StartFieldChildExecution(ctx)
2079
2080	return ec._Identity(ctx, field.Selections, &res)
2081}
2082
2083// nolint: vetshadow
2084func (ec *executionContext) _AddCommentOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) graphql.Marshaler {
2085	ctx = ec.Tracer.StartFieldExecution(ctx, field)
2086	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2087	rctx := &graphql.ResolverContext{
2088		Object: "AddCommentOperation",
2089		Args:   nil,
2090		Field:  field,
2091	}
2092	ctx = graphql.WithResolverContext(ctx, rctx)
2093	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2094	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2095		ctx = rctx // use context from middleware stack in children
2096		return ec.resolvers.AddCommentOperation().Date(rctx, obj)
2097	})
2098	if resTmp == nil {
2099		if !ec.HasError(rctx) {
2100			ec.Errorf(ctx, "must not be null")
2101		}
2102		return graphql.Null
2103	}
2104	res := resTmp.(time.Time)
2105	rctx.Result = res
2106	ctx = ec.Tracer.StartFieldChildExecution(ctx)
2107	return graphql.MarshalTime(res)
2108}
2109
2110// nolint: vetshadow
2111func (ec *executionContext) _AddCommentOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) graphql.Marshaler {
2112	ctx = ec.Tracer.StartFieldExecution(ctx, field)
2113	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2114	rctx := &graphql.ResolverContext{
2115		Object: "AddCommentOperation",
2116		Args:   nil,
2117		Field:  field,
2118	}
2119	ctx = graphql.WithResolverContext(ctx, rctx)
2120	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2121	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2122		ctx = rctx // use context from middleware stack in children
2123		return obj.Message, nil
2124	})
2125	if resTmp == nil {
2126		if !ec.HasError(rctx) {
2127			ec.Errorf(ctx, "must not be null")
2128		}
2129		return graphql.Null
2130	}
2131	res := resTmp.(string)
2132	rctx.Result = res
2133	ctx = ec.Tracer.StartFieldChildExecution(ctx)
2134	return graphql.MarshalString(res)
2135}
2136
2137// nolint: vetshadow
2138func (ec *executionContext) _AddCommentOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) graphql.Marshaler {
2139	ctx = ec.Tracer.StartFieldExecution(ctx, field)
2140	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2141	rctx := &graphql.ResolverContext{
2142		Object: "AddCommentOperation",
2143		Args:   nil,
2144		Field:  field,
2145	}
2146	ctx = graphql.WithResolverContext(ctx, rctx)
2147	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2148	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2149		ctx = rctx // use context from middleware stack in children
2150		return obj.Files, nil
2151	})
2152	if resTmp == nil {
2153		if !ec.HasError(rctx) {
2154			ec.Errorf(ctx, "must not be null")
2155		}
2156		return graphql.Null
2157	}
2158	res := resTmp.([]git.Hash)
2159	rctx.Result = res
2160	ctx = ec.Tracer.StartFieldChildExecution(ctx)
2161
2162	arr1 := make(graphql.Array, len(res))
2163
2164	for idx1 := range res {
2165		arr1[idx1] = func() graphql.Marshaler {
2166			return res[idx1]
2167		}()
2168	}
2169
2170	return arr1
2171}
2172
2173var addCommentTimelineItemImplementors = []string{"AddCommentTimelineItem", "TimelineItem"}
2174
2175// nolint: gocyclo, errcheck, gas, goconst
2176func (ec *executionContext) _AddCommentTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
2177	fields := graphql.CollectFields(ctx, sel, addCommentTimelineItemImplementors)
2178
2179	var wg sync.WaitGroup
2180	out := graphql.NewOrderedMap(len(fields))
2181	invalid := false
2182	for i, field := range fields {
2183		out.Keys[i] = field.Alias
2184
2185		switch field.Name {
2186		case "__typename":
2187			out.Values[i] = graphql.MarshalString("AddCommentTimelineItem")
2188		case "hash":
2189			out.Values[i] = ec._AddCommentTimelineItem_hash(ctx, field, obj)
2190			if out.Values[i] == graphql.Null {
2191				invalid = true
2192			}
2193		case "author":
2194			out.Values[i] = ec._AddCommentTimelineItem_author(ctx, field, obj)
2195			if out.Values[i] == graphql.Null {
2196				invalid = true
2197			}
2198		case "message":
2199			out.Values[i] = ec._AddCommentTimelineItem_message(ctx, field, obj)
2200			if out.Values[i] == graphql.Null {
2201				invalid = true
2202			}
2203		case "messageIsEmpty":
2204			out.Values[i] = ec._AddCommentTimelineItem_messageIsEmpty(ctx, field, obj)
2205			if out.Values[i] == graphql.Null {
2206				invalid = true
2207			}
2208		case "files":
2209			out.Values[i] = ec._AddCommentTimelineItem_files(ctx, field, obj)
2210			if out.Values[i] == graphql.Null {
2211				invalid = true
2212			}
2213		case "createdAt":
2214			wg.Add(1)
2215			go func(i int, field graphql.CollectedField) {
2216				out.Values[i] = ec._AddCommentTimelineItem_createdAt(ctx, field, obj)
2217				if out.Values[i] == graphql.Null {
2218					invalid = true
2219				}
2220				wg.Done()
2221			}(i, field)
2222		case "lastEdit":
2223			wg.Add(1)
2224			go func(i int, field graphql.CollectedField) {
2225				out.Values[i] = ec._AddCommentTimelineItem_lastEdit(ctx, field, obj)
2226				if out.Values[i] == graphql.Null {
2227					invalid = true
2228				}
2229				wg.Done()
2230			}(i, field)
2231		case "edited":
2232			out.Values[i] = ec._AddCommentTimelineItem_edited(ctx, field, obj)
2233			if out.Values[i] == graphql.Null {
2234				invalid = true
2235			}
2236		case "history":
2237			out.Values[i] = ec._AddCommentTimelineItem_history(ctx, field, obj)
2238			if out.Values[i] == graphql.Null {
2239				invalid = true
2240			}
2241		default:
2242			panic("unknown field " + strconv.Quote(field.Name))
2243		}
2244	}
2245	wg.Wait()
2246	if invalid {
2247		return graphql.Null
2248	}
2249	return out
2250}
2251
2252// nolint: vetshadow
2253func (ec *executionContext) _AddCommentTimelineItem_hash(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
2254	ctx = ec.Tracer.StartFieldExecution(ctx, field)
2255	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2256	rctx := &graphql.ResolverContext{
2257		Object: "AddCommentTimelineItem",
2258		Args:   nil,
2259		Field:  field,
2260	}
2261	ctx = graphql.WithResolverContext(ctx, rctx)
2262	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2263	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2264		ctx = rctx // use context from middleware stack in children
2265		return obj.Hash(), nil
2266	})
2267	if resTmp == nil {
2268		if !ec.HasError(rctx) {
2269			ec.Errorf(ctx, "must not be null")
2270		}
2271		return graphql.Null
2272	}
2273	res := resTmp.(git.Hash)
2274	rctx.Result = res
2275	ctx = ec.Tracer.StartFieldChildExecution(ctx)
2276	return res
2277}
2278
2279// nolint: vetshadow
2280func (ec *executionContext) _AddCommentTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
2281	ctx = ec.Tracer.StartFieldExecution(ctx, field)
2282	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2283	rctx := &graphql.ResolverContext{
2284		Object: "AddCommentTimelineItem",
2285		Args:   nil,
2286		Field:  field,
2287	}
2288	ctx = graphql.WithResolverContext(ctx, rctx)
2289	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2290	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2291		ctx = rctx // use context from middleware stack in children
2292		return obj.Author, nil
2293	})
2294	if resTmp == nil {
2295		if !ec.HasError(rctx) {
2296			ec.Errorf(ctx, "must not be null")
2297		}
2298		return graphql.Null
2299	}
2300	res := resTmp.(identity.Interface)
2301	rctx.Result = res
2302	ctx = ec.Tracer.StartFieldChildExecution(ctx)
2303
2304	return ec._Identity(ctx, field.Selections, &res)
2305}
2306
2307// nolint: vetshadow
2308func (ec *executionContext) _AddCommentTimelineItem_message(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
2309	ctx = ec.Tracer.StartFieldExecution(ctx, field)
2310	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2311	rctx := &graphql.ResolverContext{
2312		Object: "AddCommentTimelineItem",
2313		Args:   nil,
2314		Field:  field,
2315	}
2316	ctx = graphql.WithResolverContext(ctx, rctx)
2317	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2318	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2319		ctx = rctx // use context from middleware stack in children
2320		return obj.Message, nil
2321	})
2322	if resTmp == nil {
2323		if !ec.HasError(rctx) {
2324			ec.Errorf(ctx, "must not be null")
2325		}
2326		return graphql.Null
2327	}
2328	res := resTmp.(string)
2329	rctx.Result = res
2330	ctx = ec.Tracer.StartFieldChildExecution(ctx)
2331	return graphql.MarshalString(res)
2332}
2333
2334// nolint: vetshadow
2335func (ec *executionContext) _AddCommentTimelineItem_messageIsEmpty(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
2336	ctx = ec.Tracer.StartFieldExecution(ctx, field)
2337	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2338	rctx := &graphql.ResolverContext{
2339		Object: "AddCommentTimelineItem",
2340		Args:   nil,
2341		Field:  field,
2342	}
2343	ctx = graphql.WithResolverContext(ctx, rctx)
2344	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2345	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2346		ctx = rctx // use context from middleware stack in children
2347		return obj.MessageIsEmpty(), nil
2348	})
2349	if resTmp == nil {
2350		if !ec.HasError(rctx) {
2351			ec.Errorf(ctx, "must not be null")
2352		}
2353		return graphql.Null
2354	}
2355	res := resTmp.(bool)
2356	rctx.Result = res
2357	ctx = ec.Tracer.StartFieldChildExecution(ctx)
2358	return graphql.MarshalBoolean(res)
2359}
2360
2361// nolint: vetshadow
2362func (ec *executionContext) _AddCommentTimelineItem_files(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
2363	ctx = ec.Tracer.StartFieldExecution(ctx, field)
2364	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2365	rctx := &graphql.ResolverContext{
2366		Object: "AddCommentTimelineItem",
2367		Args:   nil,
2368		Field:  field,
2369	}
2370	ctx = graphql.WithResolverContext(ctx, rctx)
2371	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2372	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2373		ctx = rctx // use context from middleware stack in children
2374		return obj.Files, nil
2375	})
2376	if resTmp == nil {
2377		if !ec.HasError(rctx) {
2378			ec.Errorf(ctx, "must not be null")
2379		}
2380		return graphql.Null
2381	}
2382	res := resTmp.([]git.Hash)
2383	rctx.Result = res
2384	ctx = ec.Tracer.StartFieldChildExecution(ctx)
2385
2386	arr1 := make(graphql.Array, len(res))
2387
2388	for idx1 := range res {
2389		arr1[idx1] = func() graphql.Marshaler {
2390			return res[idx1]
2391		}()
2392	}
2393
2394	return arr1
2395}
2396
2397// nolint: vetshadow
2398func (ec *executionContext) _AddCommentTimelineItem_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
2399	ctx = ec.Tracer.StartFieldExecution(ctx, field)
2400	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2401	rctx := &graphql.ResolverContext{
2402		Object: "AddCommentTimelineItem",
2403		Args:   nil,
2404		Field:  field,
2405	}
2406	ctx = graphql.WithResolverContext(ctx, rctx)
2407	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2408	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2409		ctx = rctx // use context from middleware stack in children
2410		return ec.resolvers.AddCommentTimelineItem().CreatedAt(rctx, obj)
2411	})
2412	if resTmp == nil {
2413		if !ec.HasError(rctx) {
2414			ec.Errorf(ctx, "must not be null")
2415		}
2416		return graphql.Null
2417	}
2418	res := resTmp.(time.Time)
2419	rctx.Result = res
2420	ctx = ec.Tracer.StartFieldChildExecution(ctx)
2421	return graphql.MarshalTime(res)
2422}
2423
2424// nolint: vetshadow
2425func (ec *executionContext) _AddCommentTimelineItem_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
2426	ctx = ec.Tracer.StartFieldExecution(ctx, field)
2427	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2428	rctx := &graphql.ResolverContext{
2429		Object: "AddCommentTimelineItem",
2430		Args:   nil,
2431		Field:  field,
2432	}
2433	ctx = graphql.WithResolverContext(ctx, rctx)
2434	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2435	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2436		ctx = rctx // use context from middleware stack in children
2437		return ec.resolvers.AddCommentTimelineItem().LastEdit(rctx, obj)
2438	})
2439	if resTmp == nil {
2440		if !ec.HasError(rctx) {
2441			ec.Errorf(ctx, "must not be null")
2442		}
2443		return graphql.Null
2444	}
2445	res := resTmp.(time.Time)
2446	rctx.Result = res
2447	ctx = ec.Tracer.StartFieldChildExecution(ctx)
2448	return graphql.MarshalTime(res)
2449}
2450
2451// nolint: vetshadow
2452func (ec *executionContext) _AddCommentTimelineItem_edited(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
2453	ctx = ec.Tracer.StartFieldExecution(ctx, field)
2454	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2455	rctx := &graphql.ResolverContext{
2456		Object: "AddCommentTimelineItem",
2457		Args:   nil,
2458		Field:  field,
2459	}
2460	ctx = graphql.WithResolverContext(ctx, rctx)
2461	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2462	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2463		ctx = rctx // use context from middleware stack in children
2464		return obj.Edited(), nil
2465	})
2466	if resTmp == nil {
2467		if !ec.HasError(rctx) {
2468			ec.Errorf(ctx, "must not be null")
2469		}
2470		return graphql.Null
2471	}
2472	res := resTmp.(bool)
2473	rctx.Result = res
2474	ctx = ec.Tracer.StartFieldChildExecution(ctx)
2475	return graphql.MarshalBoolean(res)
2476}
2477
2478// nolint: vetshadow
2479func (ec *executionContext) _AddCommentTimelineItem_history(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
2480	ctx = ec.Tracer.StartFieldExecution(ctx, field)
2481	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2482	rctx := &graphql.ResolverContext{
2483		Object: "AddCommentTimelineItem",
2484		Args:   nil,
2485		Field:  field,
2486	}
2487	ctx = graphql.WithResolverContext(ctx, rctx)
2488	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2489	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2490		ctx = rctx // use context from middleware stack in children
2491		return obj.History, nil
2492	})
2493	if resTmp == nil {
2494		if !ec.HasError(rctx) {
2495			ec.Errorf(ctx, "must not be null")
2496		}
2497		return graphql.Null
2498	}
2499	res := resTmp.([]bug.CommentHistoryStep)
2500	rctx.Result = res
2501	ctx = ec.Tracer.StartFieldChildExecution(ctx)
2502
2503	arr1 := make(graphql.Array, len(res))
2504	var wg sync.WaitGroup
2505
2506	isLen1 := len(res) == 1
2507	if !isLen1 {
2508		wg.Add(len(res))
2509	}
2510
2511	for idx1 := range res {
2512		idx1 := idx1
2513		rctx := &graphql.ResolverContext{
2514			Index:  &idx1,
2515			Result: &res[idx1],
2516		}
2517		ctx := graphql.WithResolverContext(ctx, rctx)
2518		f := func(idx1 int) {
2519			if !isLen1 {
2520				defer wg.Done()
2521			}
2522			arr1[idx1] = func() graphql.Marshaler {
2523
2524				return ec._CommentHistoryStep(ctx, field.Selections, &res[idx1])
2525			}()
2526		}
2527		if isLen1 {
2528			f(idx1)
2529		} else {
2530			go f(idx1)
2531		}
2532
2533	}
2534	wg.Wait()
2535	return arr1
2536}
2537
2538var bugImplementors = []string{"Bug"}
2539
2540// nolint: gocyclo, errcheck, gas, goconst
2541func (ec *executionContext) _Bug(ctx context.Context, sel ast.SelectionSet, obj *bug.Snapshot) graphql.Marshaler {
2542	fields := graphql.CollectFields(ctx, sel, bugImplementors)
2543
2544	var wg sync.WaitGroup
2545	out := graphql.NewOrderedMap(len(fields))
2546	invalid := false
2547	for i, field := range fields {
2548		out.Keys[i] = field.Alias
2549
2550		switch field.Name {
2551		case "__typename":
2552			out.Values[i] = graphql.MarshalString("Bug")
2553		case "id":
2554			out.Values[i] = ec._Bug_id(ctx, field, obj)
2555			if out.Values[i] == graphql.Null {
2556				invalid = true
2557			}
2558		case "humanId":
2559			out.Values[i] = ec._Bug_humanId(ctx, field, obj)
2560			if out.Values[i] == graphql.Null {
2561				invalid = true
2562			}
2563		case "status":
2564			wg.Add(1)
2565			go func(i int, field graphql.CollectedField) {
2566				out.Values[i] = ec._Bug_status(ctx, field, obj)
2567				if out.Values[i] == graphql.Null {
2568					invalid = true
2569				}
2570				wg.Done()
2571			}(i, field)
2572		case "title":
2573			out.Values[i] = ec._Bug_title(ctx, field, obj)
2574			if out.Values[i] == graphql.Null {
2575				invalid = true
2576			}
2577		case "labels":
2578			out.Values[i] = ec._Bug_labels(ctx, field, obj)
2579			if out.Values[i] == graphql.Null {
2580				invalid = true
2581			}
2582		case "author":
2583			out.Values[i] = ec._Bug_author(ctx, field, obj)
2584			if out.Values[i] == graphql.Null {
2585				invalid = true
2586			}
2587		case "createdAt":
2588			out.Values[i] = ec._Bug_createdAt(ctx, field, obj)
2589			if out.Values[i] == graphql.Null {
2590				invalid = true
2591			}
2592		case "lastEdit":
2593			wg.Add(1)
2594			go func(i int, field graphql.CollectedField) {
2595				out.Values[i] = ec._Bug_lastEdit(ctx, field, obj)
2596				if out.Values[i] == graphql.Null {
2597					invalid = true
2598				}
2599				wg.Done()
2600			}(i, field)
2601		case "comments":
2602			wg.Add(1)
2603			go func(i int, field graphql.CollectedField) {
2604				out.Values[i] = ec._Bug_comments(ctx, field, obj)
2605				if out.Values[i] == graphql.Null {
2606					invalid = true
2607				}
2608				wg.Done()
2609			}(i, field)
2610		case "timeline":
2611			wg.Add(1)
2612			go func(i int, field graphql.CollectedField) {
2613				out.Values[i] = ec._Bug_timeline(ctx, field, obj)
2614				if out.Values[i] == graphql.Null {
2615					invalid = true
2616				}
2617				wg.Done()
2618			}(i, field)
2619		case "operations":
2620			wg.Add(1)
2621			go func(i int, field graphql.CollectedField) {
2622				out.Values[i] = ec._Bug_operations(ctx, field, obj)
2623				if out.Values[i] == graphql.Null {
2624					invalid = true
2625				}
2626				wg.Done()
2627			}(i, field)
2628		default:
2629			panic("unknown field " + strconv.Quote(field.Name))
2630		}
2631	}
2632	wg.Wait()
2633	if invalid {
2634		return graphql.Null
2635	}
2636	return out
2637}
2638
2639// nolint: vetshadow
2640func (ec *executionContext) _Bug_id(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
2641	ctx = ec.Tracer.StartFieldExecution(ctx, field)
2642	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2643	rctx := &graphql.ResolverContext{
2644		Object: "Bug",
2645		Args:   nil,
2646		Field:  field,
2647	}
2648	ctx = graphql.WithResolverContext(ctx, rctx)
2649	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2650	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2651		ctx = rctx // use context from middleware stack in children
2652		return obj.Id(), nil
2653	})
2654	if resTmp == nil {
2655		if !ec.HasError(rctx) {
2656			ec.Errorf(ctx, "must not be null")
2657		}
2658		return graphql.Null
2659	}
2660	res := resTmp.(string)
2661	rctx.Result = res
2662	ctx = ec.Tracer.StartFieldChildExecution(ctx)
2663	return graphql.MarshalString(res)
2664}
2665
2666// nolint: vetshadow
2667func (ec *executionContext) _Bug_humanId(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
2668	ctx = ec.Tracer.StartFieldExecution(ctx, field)
2669	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2670	rctx := &graphql.ResolverContext{
2671		Object: "Bug",
2672		Args:   nil,
2673		Field:  field,
2674	}
2675	ctx = graphql.WithResolverContext(ctx, rctx)
2676	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2677	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2678		ctx = rctx // use context from middleware stack in children
2679		return obj.HumanId(), nil
2680	})
2681	if resTmp == nil {
2682		if !ec.HasError(rctx) {
2683			ec.Errorf(ctx, "must not be null")
2684		}
2685		return graphql.Null
2686	}
2687	res := resTmp.(string)
2688	rctx.Result = res
2689	ctx = ec.Tracer.StartFieldChildExecution(ctx)
2690	return graphql.MarshalString(res)
2691}
2692
2693// nolint: vetshadow
2694func (ec *executionContext) _Bug_status(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
2695	ctx = ec.Tracer.StartFieldExecution(ctx, field)
2696	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2697	rctx := &graphql.ResolverContext{
2698		Object: "Bug",
2699		Args:   nil,
2700		Field:  field,
2701	}
2702	ctx = graphql.WithResolverContext(ctx, rctx)
2703	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2704	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2705		ctx = rctx // use context from middleware stack in children
2706		return ec.resolvers.Bug().Status(rctx, obj)
2707	})
2708	if resTmp == nil {
2709		if !ec.HasError(rctx) {
2710			ec.Errorf(ctx, "must not be null")
2711		}
2712		return graphql.Null
2713	}
2714	res := resTmp.(models.Status)
2715	rctx.Result = res
2716	ctx = ec.Tracer.StartFieldChildExecution(ctx)
2717	return res
2718}
2719
2720// nolint: vetshadow
2721func (ec *executionContext) _Bug_title(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
2722	ctx = ec.Tracer.StartFieldExecution(ctx, field)
2723	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2724	rctx := &graphql.ResolverContext{
2725		Object: "Bug",
2726		Args:   nil,
2727		Field:  field,
2728	}
2729	ctx = graphql.WithResolverContext(ctx, rctx)
2730	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2731	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2732		ctx = rctx // use context from middleware stack in children
2733		return obj.Title, nil
2734	})
2735	if resTmp == nil {
2736		if !ec.HasError(rctx) {
2737			ec.Errorf(ctx, "must not be null")
2738		}
2739		return graphql.Null
2740	}
2741	res := resTmp.(string)
2742	rctx.Result = res
2743	ctx = ec.Tracer.StartFieldChildExecution(ctx)
2744	return graphql.MarshalString(res)
2745}
2746
2747// nolint: vetshadow
2748func (ec *executionContext) _Bug_labels(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
2749	ctx = ec.Tracer.StartFieldExecution(ctx, field)
2750	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2751	rctx := &graphql.ResolverContext{
2752		Object: "Bug",
2753		Args:   nil,
2754		Field:  field,
2755	}
2756	ctx = graphql.WithResolverContext(ctx, rctx)
2757	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2758	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2759		ctx = rctx // use context from middleware stack in children
2760		return obj.Labels, nil
2761	})
2762	if resTmp == nil {
2763		if !ec.HasError(rctx) {
2764			ec.Errorf(ctx, "must not be null")
2765		}
2766		return graphql.Null
2767	}
2768	res := resTmp.([]bug.Label)
2769	rctx.Result = res
2770	ctx = ec.Tracer.StartFieldChildExecution(ctx)
2771
2772	arr1 := make(graphql.Array, len(res))
2773
2774	for idx1 := range res {
2775		arr1[idx1] = func() graphql.Marshaler {
2776			return res[idx1]
2777		}()
2778	}
2779
2780	return arr1
2781}
2782
2783// nolint: vetshadow
2784func (ec *executionContext) _Bug_author(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
2785	ctx = ec.Tracer.StartFieldExecution(ctx, field)
2786	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2787	rctx := &graphql.ResolverContext{
2788		Object: "Bug",
2789		Args:   nil,
2790		Field:  field,
2791	}
2792	ctx = graphql.WithResolverContext(ctx, rctx)
2793	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2794	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2795		ctx = rctx // use context from middleware stack in children
2796		return obj.Author, nil
2797	})
2798	if resTmp == nil {
2799		if !ec.HasError(rctx) {
2800			ec.Errorf(ctx, "must not be null")
2801		}
2802		return graphql.Null
2803	}
2804	res := resTmp.(identity.Interface)
2805	rctx.Result = res
2806	ctx = ec.Tracer.StartFieldChildExecution(ctx)
2807
2808	return ec._Identity(ctx, field.Selections, &res)
2809}
2810
2811// nolint: vetshadow
2812func (ec *executionContext) _Bug_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
2813	ctx = ec.Tracer.StartFieldExecution(ctx, field)
2814	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2815	rctx := &graphql.ResolverContext{
2816		Object: "Bug",
2817		Args:   nil,
2818		Field:  field,
2819	}
2820	ctx = graphql.WithResolverContext(ctx, rctx)
2821	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2822	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2823		ctx = rctx // use context from middleware stack in children
2824		return obj.CreatedAt, nil
2825	})
2826	if resTmp == nil {
2827		if !ec.HasError(rctx) {
2828			ec.Errorf(ctx, "must not be null")
2829		}
2830		return graphql.Null
2831	}
2832	res := resTmp.(time.Time)
2833	rctx.Result = res
2834	ctx = ec.Tracer.StartFieldChildExecution(ctx)
2835	return graphql.MarshalTime(res)
2836}
2837
2838// nolint: vetshadow
2839func (ec *executionContext) _Bug_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
2840	ctx = ec.Tracer.StartFieldExecution(ctx, field)
2841	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2842	rctx := &graphql.ResolverContext{
2843		Object: "Bug",
2844		Args:   nil,
2845		Field:  field,
2846	}
2847	ctx = graphql.WithResolverContext(ctx, rctx)
2848	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2849	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2850		ctx = rctx // use context from middleware stack in children
2851		return ec.resolvers.Bug().LastEdit(rctx, obj)
2852	})
2853	if resTmp == nil {
2854		if !ec.HasError(rctx) {
2855			ec.Errorf(ctx, "must not be null")
2856		}
2857		return graphql.Null
2858	}
2859	res := resTmp.(time.Time)
2860	rctx.Result = res
2861	ctx = ec.Tracer.StartFieldChildExecution(ctx)
2862	return graphql.MarshalTime(res)
2863}
2864
2865// nolint: vetshadow
2866func (ec *executionContext) _Bug_comments(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
2867	ctx = ec.Tracer.StartFieldExecution(ctx, field)
2868	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2869	rawArgs := field.ArgumentMap(ec.Variables)
2870	args, err := field_Bug_comments_args(rawArgs)
2871	if err != nil {
2872		ec.Error(ctx, err)
2873		return graphql.Null
2874	}
2875	rctx := &graphql.ResolverContext{
2876		Object: "Bug",
2877		Args:   args,
2878		Field:  field,
2879	}
2880	ctx = graphql.WithResolverContext(ctx, rctx)
2881	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2882	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2883		ctx = rctx // use context from middleware stack in children
2884		return ec.resolvers.Bug().Comments(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
2885	})
2886	if resTmp == nil {
2887		if !ec.HasError(rctx) {
2888			ec.Errorf(ctx, "must not be null")
2889		}
2890		return graphql.Null
2891	}
2892	res := resTmp.(models.CommentConnection)
2893	rctx.Result = res
2894	ctx = ec.Tracer.StartFieldChildExecution(ctx)
2895
2896	return ec._CommentConnection(ctx, field.Selections, &res)
2897}
2898
2899// nolint: vetshadow
2900func (ec *executionContext) _Bug_timeline(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
2901	ctx = ec.Tracer.StartFieldExecution(ctx, field)
2902	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2903	rawArgs := field.ArgumentMap(ec.Variables)
2904	args, err := field_Bug_timeline_args(rawArgs)
2905	if err != nil {
2906		ec.Error(ctx, err)
2907		return graphql.Null
2908	}
2909	rctx := &graphql.ResolverContext{
2910		Object: "Bug",
2911		Args:   args,
2912		Field:  field,
2913	}
2914	ctx = graphql.WithResolverContext(ctx, rctx)
2915	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2916	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2917		ctx = rctx // use context from middleware stack in children
2918		return ec.resolvers.Bug().Timeline(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
2919	})
2920	if resTmp == nil {
2921		if !ec.HasError(rctx) {
2922			ec.Errorf(ctx, "must not be null")
2923		}
2924		return graphql.Null
2925	}
2926	res := resTmp.(models.TimelineItemConnection)
2927	rctx.Result = res
2928	ctx = ec.Tracer.StartFieldChildExecution(ctx)
2929
2930	return ec._TimelineItemConnection(ctx, field.Selections, &res)
2931}
2932
2933// nolint: vetshadow
2934func (ec *executionContext) _Bug_operations(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
2935	ctx = ec.Tracer.StartFieldExecution(ctx, field)
2936	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
2937	rawArgs := field.ArgumentMap(ec.Variables)
2938	args, err := field_Bug_operations_args(rawArgs)
2939	if err != nil {
2940		ec.Error(ctx, err)
2941		return graphql.Null
2942	}
2943	rctx := &graphql.ResolverContext{
2944		Object: "Bug",
2945		Args:   args,
2946		Field:  field,
2947	}
2948	ctx = graphql.WithResolverContext(ctx, rctx)
2949	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
2950	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
2951		ctx = rctx // use context from middleware stack in children
2952		return ec.resolvers.Bug().Operations(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
2953	})
2954	if resTmp == nil {
2955		if !ec.HasError(rctx) {
2956			ec.Errorf(ctx, "must not be null")
2957		}
2958		return graphql.Null
2959	}
2960	res := resTmp.(models.OperationConnection)
2961	rctx.Result = res
2962	ctx = ec.Tracer.StartFieldChildExecution(ctx)
2963
2964	return ec._OperationConnection(ctx, field.Selections, &res)
2965}
2966
2967var bugConnectionImplementors = []string{"BugConnection"}
2968
2969// nolint: gocyclo, errcheck, gas, goconst
2970func (ec *executionContext) _BugConnection(ctx context.Context, sel ast.SelectionSet, obj *models.BugConnection) graphql.Marshaler {
2971	fields := graphql.CollectFields(ctx, sel, bugConnectionImplementors)
2972
2973	out := graphql.NewOrderedMap(len(fields))
2974	invalid := false
2975	for i, field := range fields {
2976		out.Keys[i] = field.Alias
2977
2978		switch field.Name {
2979		case "__typename":
2980			out.Values[i] = graphql.MarshalString("BugConnection")
2981		case "edges":
2982			out.Values[i] = ec._BugConnection_edges(ctx, field, obj)
2983			if out.Values[i] == graphql.Null {
2984				invalid = true
2985			}
2986		case "nodes":
2987			out.Values[i] = ec._BugConnection_nodes(ctx, field, obj)
2988			if out.Values[i] == graphql.Null {
2989				invalid = true
2990			}
2991		case "pageInfo":
2992			out.Values[i] = ec._BugConnection_pageInfo(ctx, field, obj)
2993			if out.Values[i] == graphql.Null {
2994				invalid = true
2995			}
2996		case "totalCount":
2997			out.Values[i] = ec._BugConnection_totalCount(ctx, field, obj)
2998			if out.Values[i] == graphql.Null {
2999				invalid = true
3000			}
3001		default:
3002			panic("unknown field " + strconv.Quote(field.Name))
3003		}
3004	}
3005
3006	if invalid {
3007		return graphql.Null
3008	}
3009	return out
3010}
3011
3012// nolint: vetshadow
3013func (ec *executionContext) _BugConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) graphql.Marshaler {
3014	ctx = ec.Tracer.StartFieldExecution(ctx, field)
3015	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3016	rctx := &graphql.ResolverContext{
3017		Object: "BugConnection",
3018		Args:   nil,
3019		Field:  field,
3020	}
3021	ctx = graphql.WithResolverContext(ctx, rctx)
3022	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3023	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3024		ctx = rctx // use context from middleware stack in children
3025		return obj.Edges, nil
3026	})
3027	if resTmp == nil {
3028		if !ec.HasError(rctx) {
3029			ec.Errorf(ctx, "must not be null")
3030		}
3031		return graphql.Null
3032	}
3033	res := resTmp.([]models.BugEdge)
3034	rctx.Result = res
3035	ctx = ec.Tracer.StartFieldChildExecution(ctx)
3036
3037	arr1 := make(graphql.Array, len(res))
3038	var wg sync.WaitGroup
3039
3040	isLen1 := len(res) == 1
3041	if !isLen1 {
3042		wg.Add(len(res))
3043	}
3044
3045	for idx1 := range res {
3046		idx1 := idx1
3047		rctx := &graphql.ResolverContext{
3048			Index:  &idx1,
3049			Result: &res[idx1],
3050		}
3051		ctx := graphql.WithResolverContext(ctx, rctx)
3052		f := func(idx1 int) {
3053			if !isLen1 {
3054				defer wg.Done()
3055			}
3056			arr1[idx1] = func() graphql.Marshaler {
3057
3058				return ec._BugEdge(ctx, field.Selections, &res[idx1])
3059			}()
3060		}
3061		if isLen1 {
3062			f(idx1)
3063		} else {
3064			go f(idx1)
3065		}
3066
3067	}
3068	wg.Wait()
3069	return arr1
3070}
3071
3072// nolint: vetshadow
3073func (ec *executionContext) _BugConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) graphql.Marshaler {
3074	ctx = ec.Tracer.StartFieldExecution(ctx, field)
3075	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3076	rctx := &graphql.ResolverContext{
3077		Object: "BugConnection",
3078		Args:   nil,
3079		Field:  field,
3080	}
3081	ctx = graphql.WithResolverContext(ctx, rctx)
3082	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3083	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3084		ctx = rctx // use context from middleware stack in children
3085		return obj.Nodes, nil
3086	})
3087	if resTmp == nil {
3088		if !ec.HasError(rctx) {
3089			ec.Errorf(ctx, "must not be null")
3090		}
3091		return graphql.Null
3092	}
3093	res := resTmp.([]bug.Snapshot)
3094	rctx.Result = res
3095	ctx = ec.Tracer.StartFieldChildExecution(ctx)
3096
3097	arr1 := make(graphql.Array, len(res))
3098	var wg sync.WaitGroup
3099
3100	isLen1 := len(res) == 1
3101	if !isLen1 {
3102		wg.Add(len(res))
3103	}
3104
3105	for idx1 := range res {
3106		idx1 := idx1
3107		rctx := &graphql.ResolverContext{
3108			Index:  &idx1,
3109			Result: &res[idx1],
3110		}
3111		ctx := graphql.WithResolverContext(ctx, rctx)
3112		f := func(idx1 int) {
3113			if !isLen1 {
3114				defer wg.Done()
3115			}
3116			arr1[idx1] = func() graphql.Marshaler {
3117
3118				return ec._Bug(ctx, field.Selections, &res[idx1])
3119			}()
3120		}
3121		if isLen1 {
3122			f(idx1)
3123		} else {
3124			go f(idx1)
3125		}
3126
3127	}
3128	wg.Wait()
3129	return arr1
3130}
3131
3132// nolint: vetshadow
3133func (ec *executionContext) _BugConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) graphql.Marshaler {
3134	ctx = ec.Tracer.StartFieldExecution(ctx, field)
3135	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3136	rctx := &graphql.ResolverContext{
3137		Object: "BugConnection",
3138		Args:   nil,
3139		Field:  field,
3140	}
3141	ctx = graphql.WithResolverContext(ctx, rctx)
3142	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3143	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3144		ctx = rctx // use context from middleware stack in children
3145		return obj.PageInfo, nil
3146	})
3147	if resTmp == nil {
3148		if !ec.HasError(rctx) {
3149			ec.Errorf(ctx, "must not be null")
3150		}
3151		return graphql.Null
3152	}
3153	res := resTmp.(models.PageInfo)
3154	rctx.Result = res
3155	ctx = ec.Tracer.StartFieldChildExecution(ctx)
3156
3157	return ec._PageInfo(ctx, field.Selections, &res)
3158}
3159
3160// nolint: vetshadow
3161func (ec *executionContext) _BugConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) graphql.Marshaler {
3162	ctx = ec.Tracer.StartFieldExecution(ctx, field)
3163	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3164	rctx := &graphql.ResolverContext{
3165		Object: "BugConnection",
3166		Args:   nil,
3167		Field:  field,
3168	}
3169	ctx = graphql.WithResolverContext(ctx, rctx)
3170	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3171	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3172		ctx = rctx // use context from middleware stack in children
3173		return obj.TotalCount, nil
3174	})
3175	if resTmp == nil {
3176		if !ec.HasError(rctx) {
3177			ec.Errorf(ctx, "must not be null")
3178		}
3179		return graphql.Null
3180	}
3181	res := resTmp.(int)
3182	rctx.Result = res
3183	ctx = ec.Tracer.StartFieldChildExecution(ctx)
3184	return graphql.MarshalInt(res)
3185}
3186
3187var bugEdgeImplementors = []string{"BugEdge"}
3188
3189// nolint: gocyclo, errcheck, gas, goconst
3190func (ec *executionContext) _BugEdge(ctx context.Context, sel ast.SelectionSet, obj *models.BugEdge) graphql.Marshaler {
3191	fields := graphql.CollectFields(ctx, sel, bugEdgeImplementors)
3192
3193	out := graphql.NewOrderedMap(len(fields))
3194	invalid := false
3195	for i, field := range fields {
3196		out.Keys[i] = field.Alias
3197
3198		switch field.Name {
3199		case "__typename":
3200			out.Values[i] = graphql.MarshalString("BugEdge")
3201		case "cursor":
3202			out.Values[i] = ec._BugEdge_cursor(ctx, field, obj)
3203			if out.Values[i] == graphql.Null {
3204				invalid = true
3205			}
3206		case "node":
3207			out.Values[i] = ec._BugEdge_node(ctx, field, obj)
3208			if out.Values[i] == graphql.Null {
3209				invalid = true
3210			}
3211		default:
3212			panic("unknown field " + strconv.Quote(field.Name))
3213		}
3214	}
3215
3216	if invalid {
3217		return graphql.Null
3218	}
3219	return out
3220}
3221
3222// nolint: vetshadow
3223func (ec *executionContext) _BugEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.BugEdge) graphql.Marshaler {
3224	ctx = ec.Tracer.StartFieldExecution(ctx, field)
3225	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3226	rctx := &graphql.ResolverContext{
3227		Object: "BugEdge",
3228		Args:   nil,
3229		Field:  field,
3230	}
3231	ctx = graphql.WithResolverContext(ctx, rctx)
3232	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3233	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3234		ctx = rctx // use context from middleware stack in children
3235		return obj.Cursor, nil
3236	})
3237	if resTmp == nil {
3238		if !ec.HasError(rctx) {
3239			ec.Errorf(ctx, "must not be null")
3240		}
3241		return graphql.Null
3242	}
3243	res := resTmp.(string)
3244	rctx.Result = res
3245	ctx = ec.Tracer.StartFieldChildExecution(ctx)
3246	return graphql.MarshalString(res)
3247}
3248
3249// nolint: vetshadow
3250func (ec *executionContext) _BugEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.BugEdge) graphql.Marshaler {
3251	ctx = ec.Tracer.StartFieldExecution(ctx, field)
3252	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3253	rctx := &graphql.ResolverContext{
3254		Object: "BugEdge",
3255		Args:   nil,
3256		Field:  field,
3257	}
3258	ctx = graphql.WithResolverContext(ctx, rctx)
3259	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3260	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3261		ctx = rctx // use context from middleware stack in children
3262		return obj.Node, nil
3263	})
3264	if resTmp == nil {
3265		if !ec.HasError(rctx) {
3266			ec.Errorf(ctx, "must not be null")
3267		}
3268		return graphql.Null
3269	}
3270	res := resTmp.(bug.Snapshot)
3271	rctx.Result = res
3272	ctx = ec.Tracer.StartFieldChildExecution(ctx)
3273
3274	return ec._Bug(ctx, field.Selections, &res)
3275}
3276
3277var commentImplementors = []string{"Comment", "Authored"}
3278
3279// nolint: gocyclo, errcheck, gas, goconst
3280func (ec *executionContext) _Comment(ctx context.Context, sel ast.SelectionSet, obj *bug.Comment) graphql.Marshaler {
3281	fields := graphql.CollectFields(ctx, sel, commentImplementors)
3282
3283	out := graphql.NewOrderedMap(len(fields))
3284	invalid := false
3285	for i, field := range fields {
3286		out.Keys[i] = field.Alias
3287
3288		switch field.Name {
3289		case "__typename":
3290			out.Values[i] = graphql.MarshalString("Comment")
3291		case "author":
3292			out.Values[i] = ec._Comment_author(ctx, field, obj)
3293			if out.Values[i] == graphql.Null {
3294				invalid = true
3295			}
3296		case "message":
3297			out.Values[i] = ec._Comment_message(ctx, field, obj)
3298			if out.Values[i] == graphql.Null {
3299				invalid = true
3300			}
3301		case "files":
3302			out.Values[i] = ec._Comment_files(ctx, field, obj)
3303			if out.Values[i] == graphql.Null {
3304				invalid = true
3305			}
3306		default:
3307			panic("unknown field " + strconv.Quote(field.Name))
3308		}
3309	}
3310
3311	if invalid {
3312		return graphql.Null
3313	}
3314	return out
3315}
3316
3317// nolint: vetshadow
3318func (ec *executionContext) _Comment_author(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) graphql.Marshaler {
3319	ctx = ec.Tracer.StartFieldExecution(ctx, field)
3320	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3321	rctx := &graphql.ResolverContext{
3322		Object: "Comment",
3323		Args:   nil,
3324		Field:  field,
3325	}
3326	ctx = graphql.WithResolverContext(ctx, rctx)
3327	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3328	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3329		ctx = rctx // use context from middleware stack in children
3330		return obj.Author, nil
3331	})
3332	if resTmp == nil {
3333		if !ec.HasError(rctx) {
3334			ec.Errorf(ctx, "must not be null")
3335		}
3336		return graphql.Null
3337	}
3338	res := resTmp.(identity.Interface)
3339	rctx.Result = res
3340	ctx = ec.Tracer.StartFieldChildExecution(ctx)
3341
3342	return ec._Identity(ctx, field.Selections, &res)
3343}
3344
3345// nolint: vetshadow
3346func (ec *executionContext) _Comment_message(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) graphql.Marshaler {
3347	ctx = ec.Tracer.StartFieldExecution(ctx, field)
3348	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3349	rctx := &graphql.ResolverContext{
3350		Object: "Comment",
3351		Args:   nil,
3352		Field:  field,
3353	}
3354	ctx = graphql.WithResolverContext(ctx, rctx)
3355	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3356	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3357		ctx = rctx // use context from middleware stack in children
3358		return obj.Message, nil
3359	})
3360	if resTmp == nil {
3361		if !ec.HasError(rctx) {
3362			ec.Errorf(ctx, "must not be null")
3363		}
3364		return graphql.Null
3365	}
3366	res := resTmp.(string)
3367	rctx.Result = res
3368	ctx = ec.Tracer.StartFieldChildExecution(ctx)
3369	return graphql.MarshalString(res)
3370}
3371
3372// nolint: vetshadow
3373func (ec *executionContext) _Comment_files(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) graphql.Marshaler {
3374	ctx = ec.Tracer.StartFieldExecution(ctx, field)
3375	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3376	rctx := &graphql.ResolverContext{
3377		Object: "Comment",
3378		Args:   nil,
3379		Field:  field,
3380	}
3381	ctx = graphql.WithResolverContext(ctx, rctx)
3382	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3383	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3384		ctx = rctx // use context from middleware stack in children
3385		return obj.Files, nil
3386	})
3387	if resTmp == nil {
3388		if !ec.HasError(rctx) {
3389			ec.Errorf(ctx, "must not be null")
3390		}
3391		return graphql.Null
3392	}
3393	res := resTmp.([]git.Hash)
3394	rctx.Result = res
3395	ctx = ec.Tracer.StartFieldChildExecution(ctx)
3396
3397	arr1 := make(graphql.Array, len(res))
3398
3399	for idx1 := range res {
3400		arr1[idx1] = func() graphql.Marshaler {
3401			return res[idx1]
3402		}()
3403	}
3404
3405	return arr1
3406}
3407
3408var commentConnectionImplementors = []string{"CommentConnection"}
3409
3410// nolint: gocyclo, errcheck, gas, goconst
3411func (ec *executionContext) _CommentConnection(ctx context.Context, sel ast.SelectionSet, obj *models.CommentConnection) graphql.Marshaler {
3412	fields := graphql.CollectFields(ctx, sel, commentConnectionImplementors)
3413
3414	out := graphql.NewOrderedMap(len(fields))
3415	invalid := false
3416	for i, field := range fields {
3417		out.Keys[i] = field.Alias
3418
3419		switch field.Name {
3420		case "__typename":
3421			out.Values[i] = graphql.MarshalString("CommentConnection")
3422		case "edges":
3423			out.Values[i] = ec._CommentConnection_edges(ctx, field, obj)
3424			if out.Values[i] == graphql.Null {
3425				invalid = true
3426			}
3427		case "nodes":
3428			out.Values[i] = ec._CommentConnection_nodes(ctx, field, obj)
3429			if out.Values[i] == graphql.Null {
3430				invalid = true
3431			}
3432		case "pageInfo":
3433			out.Values[i] = ec._CommentConnection_pageInfo(ctx, field, obj)
3434			if out.Values[i] == graphql.Null {
3435				invalid = true
3436			}
3437		case "totalCount":
3438			out.Values[i] = ec._CommentConnection_totalCount(ctx, field, obj)
3439			if out.Values[i] == graphql.Null {
3440				invalid = true
3441			}
3442		default:
3443			panic("unknown field " + strconv.Quote(field.Name))
3444		}
3445	}
3446
3447	if invalid {
3448		return graphql.Null
3449	}
3450	return out
3451}
3452
3453// nolint: vetshadow
3454func (ec *executionContext) _CommentConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) graphql.Marshaler {
3455	ctx = ec.Tracer.StartFieldExecution(ctx, field)
3456	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3457	rctx := &graphql.ResolverContext{
3458		Object: "CommentConnection",
3459		Args:   nil,
3460		Field:  field,
3461	}
3462	ctx = graphql.WithResolverContext(ctx, rctx)
3463	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3464	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3465		ctx = rctx // use context from middleware stack in children
3466		return obj.Edges, nil
3467	})
3468	if resTmp == nil {
3469		if !ec.HasError(rctx) {
3470			ec.Errorf(ctx, "must not be null")
3471		}
3472		return graphql.Null
3473	}
3474	res := resTmp.([]models.CommentEdge)
3475	rctx.Result = res
3476	ctx = ec.Tracer.StartFieldChildExecution(ctx)
3477
3478	arr1 := make(graphql.Array, len(res))
3479	var wg sync.WaitGroup
3480
3481	isLen1 := len(res) == 1
3482	if !isLen1 {
3483		wg.Add(len(res))
3484	}
3485
3486	for idx1 := range res {
3487		idx1 := idx1
3488		rctx := &graphql.ResolverContext{
3489			Index:  &idx1,
3490			Result: &res[idx1],
3491		}
3492		ctx := graphql.WithResolverContext(ctx, rctx)
3493		f := func(idx1 int) {
3494			if !isLen1 {
3495				defer wg.Done()
3496			}
3497			arr1[idx1] = func() graphql.Marshaler {
3498
3499				return ec._CommentEdge(ctx, field.Selections, &res[idx1])
3500			}()
3501		}
3502		if isLen1 {
3503			f(idx1)
3504		} else {
3505			go f(idx1)
3506		}
3507
3508	}
3509	wg.Wait()
3510	return arr1
3511}
3512
3513// nolint: vetshadow
3514func (ec *executionContext) _CommentConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) graphql.Marshaler {
3515	ctx = ec.Tracer.StartFieldExecution(ctx, field)
3516	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3517	rctx := &graphql.ResolverContext{
3518		Object: "CommentConnection",
3519		Args:   nil,
3520		Field:  field,
3521	}
3522	ctx = graphql.WithResolverContext(ctx, rctx)
3523	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3524	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3525		ctx = rctx // use context from middleware stack in children
3526		return obj.Nodes, nil
3527	})
3528	if resTmp == nil {
3529		if !ec.HasError(rctx) {
3530			ec.Errorf(ctx, "must not be null")
3531		}
3532		return graphql.Null
3533	}
3534	res := resTmp.([]bug.Comment)
3535	rctx.Result = res
3536	ctx = ec.Tracer.StartFieldChildExecution(ctx)
3537
3538	arr1 := make(graphql.Array, len(res))
3539	var wg sync.WaitGroup
3540
3541	isLen1 := len(res) == 1
3542	if !isLen1 {
3543		wg.Add(len(res))
3544	}
3545
3546	for idx1 := range res {
3547		idx1 := idx1
3548		rctx := &graphql.ResolverContext{
3549			Index:  &idx1,
3550			Result: &res[idx1],
3551		}
3552		ctx := graphql.WithResolverContext(ctx, rctx)
3553		f := func(idx1 int) {
3554			if !isLen1 {
3555				defer wg.Done()
3556			}
3557			arr1[idx1] = func() graphql.Marshaler {
3558
3559				return ec._Comment(ctx, field.Selections, &res[idx1])
3560			}()
3561		}
3562		if isLen1 {
3563			f(idx1)
3564		} else {
3565			go f(idx1)
3566		}
3567
3568	}
3569	wg.Wait()
3570	return arr1
3571}
3572
3573// nolint: vetshadow
3574func (ec *executionContext) _CommentConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) graphql.Marshaler {
3575	ctx = ec.Tracer.StartFieldExecution(ctx, field)
3576	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3577	rctx := &graphql.ResolverContext{
3578		Object: "CommentConnection",
3579		Args:   nil,
3580		Field:  field,
3581	}
3582	ctx = graphql.WithResolverContext(ctx, rctx)
3583	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3584	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3585		ctx = rctx // use context from middleware stack in children
3586		return obj.PageInfo, nil
3587	})
3588	if resTmp == nil {
3589		if !ec.HasError(rctx) {
3590			ec.Errorf(ctx, "must not be null")
3591		}
3592		return graphql.Null
3593	}
3594	res := resTmp.(models.PageInfo)
3595	rctx.Result = res
3596	ctx = ec.Tracer.StartFieldChildExecution(ctx)
3597
3598	return ec._PageInfo(ctx, field.Selections, &res)
3599}
3600
3601// nolint: vetshadow
3602func (ec *executionContext) _CommentConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) graphql.Marshaler {
3603	ctx = ec.Tracer.StartFieldExecution(ctx, field)
3604	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3605	rctx := &graphql.ResolverContext{
3606		Object: "CommentConnection",
3607		Args:   nil,
3608		Field:  field,
3609	}
3610	ctx = graphql.WithResolverContext(ctx, rctx)
3611	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3612	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3613		ctx = rctx // use context from middleware stack in children
3614		return obj.TotalCount, nil
3615	})
3616	if resTmp == nil {
3617		if !ec.HasError(rctx) {
3618			ec.Errorf(ctx, "must not be null")
3619		}
3620		return graphql.Null
3621	}
3622	res := resTmp.(int)
3623	rctx.Result = res
3624	ctx = ec.Tracer.StartFieldChildExecution(ctx)
3625	return graphql.MarshalInt(res)
3626}
3627
3628var commentEdgeImplementors = []string{"CommentEdge"}
3629
3630// nolint: gocyclo, errcheck, gas, goconst
3631func (ec *executionContext) _CommentEdge(ctx context.Context, sel ast.SelectionSet, obj *models.CommentEdge) graphql.Marshaler {
3632	fields := graphql.CollectFields(ctx, sel, commentEdgeImplementors)
3633
3634	out := graphql.NewOrderedMap(len(fields))
3635	invalid := false
3636	for i, field := range fields {
3637		out.Keys[i] = field.Alias
3638
3639		switch field.Name {
3640		case "__typename":
3641			out.Values[i] = graphql.MarshalString("CommentEdge")
3642		case "cursor":
3643			out.Values[i] = ec._CommentEdge_cursor(ctx, field, obj)
3644			if out.Values[i] == graphql.Null {
3645				invalid = true
3646			}
3647		case "node":
3648			out.Values[i] = ec._CommentEdge_node(ctx, field, obj)
3649			if out.Values[i] == graphql.Null {
3650				invalid = true
3651			}
3652		default:
3653			panic("unknown field " + strconv.Quote(field.Name))
3654		}
3655	}
3656
3657	if invalid {
3658		return graphql.Null
3659	}
3660	return out
3661}
3662
3663// nolint: vetshadow
3664func (ec *executionContext) _CommentEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.CommentEdge) graphql.Marshaler {
3665	ctx = ec.Tracer.StartFieldExecution(ctx, field)
3666	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3667	rctx := &graphql.ResolverContext{
3668		Object: "CommentEdge",
3669		Args:   nil,
3670		Field:  field,
3671	}
3672	ctx = graphql.WithResolverContext(ctx, rctx)
3673	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3674	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3675		ctx = rctx // use context from middleware stack in children
3676		return obj.Cursor, nil
3677	})
3678	if resTmp == nil {
3679		if !ec.HasError(rctx) {
3680			ec.Errorf(ctx, "must not be null")
3681		}
3682		return graphql.Null
3683	}
3684	res := resTmp.(string)
3685	rctx.Result = res
3686	ctx = ec.Tracer.StartFieldChildExecution(ctx)
3687	return graphql.MarshalString(res)
3688}
3689
3690// nolint: vetshadow
3691func (ec *executionContext) _CommentEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.CommentEdge) graphql.Marshaler {
3692	ctx = ec.Tracer.StartFieldExecution(ctx, field)
3693	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3694	rctx := &graphql.ResolverContext{
3695		Object: "CommentEdge",
3696		Args:   nil,
3697		Field:  field,
3698	}
3699	ctx = graphql.WithResolverContext(ctx, rctx)
3700	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3701	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3702		ctx = rctx // use context from middleware stack in children
3703		return obj.Node, nil
3704	})
3705	if resTmp == nil {
3706		if !ec.HasError(rctx) {
3707			ec.Errorf(ctx, "must not be null")
3708		}
3709		return graphql.Null
3710	}
3711	res := resTmp.(bug.Comment)
3712	rctx.Result = res
3713	ctx = ec.Tracer.StartFieldChildExecution(ctx)
3714
3715	return ec._Comment(ctx, field.Selections, &res)
3716}
3717
3718var commentHistoryStepImplementors = []string{"CommentHistoryStep"}
3719
3720// nolint: gocyclo, errcheck, gas, goconst
3721func (ec *executionContext) _CommentHistoryStep(ctx context.Context, sel ast.SelectionSet, obj *bug.CommentHistoryStep) graphql.Marshaler {
3722	fields := graphql.CollectFields(ctx, sel, commentHistoryStepImplementors)
3723
3724	var wg sync.WaitGroup
3725	out := graphql.NewOrderedMap(len(fields))
3726	invalid := false
3727	for i, field := range fields {
3728		out.Keys[i] = field.Alias
3729
3730		switch field.Name {
3731		case "__typename":
3732			out.Values[i] = graphql.MarshalString("CommentHistoryStep")
3733		case "message":
3734			out.Values[i] = ec._CommentHistoryStep_message(ctx, field, obj)
3735			if out.Values[i] == graphql.Null {
3736				invalid = true
3737			}
3738		case "date":
3739			wg.Add(1)
3740			go func(i int, field graphql.CollectedField) {
3741				out.Values[i] = ec._CommentHistoryStep_date(ctx, field, obj)
3742				if out.Values[i] == graphql.Null {
3743					invalid = true
3744				}
3745				wg.Done()
3746			}(i, field)
3747		default:
3748			panic("unknown field " + strconv.Quote(field.Name))
3749		}
3750	}
3751	wg.Wait()
3752	if invalid {
3753		return graphql.Null
3754	}
3755	return out
3756}
3757
3758// nolint: vetshadow
3759func (ec *executionContext) _CommentHistoryStep_message(ctx context.Context, field graphql.CollectedField, obj *bug.CommentHistoryStep) graphql.Marshaler {
3760	ctx = ec.Tracer.StartFieldExecution(ctx, field)
3761	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3762	rctx := &graphql.ResolverContext{
3763		Object: "CommentHistoryStep",
3764		Args:   nil,
3765		Field:  field,
3766	}
3767	ctx = graphql.WithResolverContext(ctx, rctx)
3768	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3769	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3770		ctx = rctx // use context from middleware stack in children
3771		return obj.Message, nil
3772	})
3773	if resTmp == nil {
3774		if !ec.HasError(rctx) {
3775			ec.Errorf(ctx, "must not be null")
3776		}
3777		return graphql.Null
3778	}
3779	res := resTmp.(string)
3780	rctx.Result = res
3781	ctx = ec.Tracer.StartFieldChildExecution(ctx)
3782	return graphql.MarshalString(res)
3783}
3784
3785// nolint: vetshadow
3786func (ec *executionContext) _CommentHistoryStep_date(ctx context.Context, field graphql.CollectedField, obj *bug.CommentHistoryStep) graphql.Marshaler {
3787	ctx = ec.Tracer.StartFieldExecution(ctx, field)
3788	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3789	rctx := &graphql.ResolverContext{
3790		Object: "CommentHistoryStep",
3791		Args:   nil,
3792		Field:  field,
3793	}
3794	ctx = graphql.WithResolverContext(ctx, rctx)
3795	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3796	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3797		ctx = rctx // use context from middleware stack in children
3798		return ec.resolvers.CommentHistoryStep().Date(rctx, obj)
3799	})
3800	if resTmp == nil {
3801		if !ec.HasError(rctx) {
3802			ec.Errorf(ctx, "must not be null")
3803		}
3804		return graphql.Null
3805	}
3806	res := resTmp.(time.Time)
3807	rctx.Result = res
3808	ctx = ec.Tracer.StartFieldChildExecution(ctx)
3809	return graphql.MarshalTime(res)
3810}
3811
3812var createOperationImplementors = []string{"CreateOperation", "Operation", "Authored"}
3813
3814// nolint: gocyclo, errcheck, gas, goconst
3815func (ec *executionContext) _CreateOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.CreateOperation) graphql.Marshaler {
3816	fields := graphql.CollectFields(ctx, sel, createOperationImplementors)
3817
3818	var wg sync.WaitGroup
3819	out := graphql.NewOrderedMap(len(fields))
3820	invalid := false
3821	for i, field := range fields {
3822		out.Keys[i] = field.Alias
3823
3824		switch field.Name {
3825		case "__typename":
3826			out.Values[i] = graphql.MarshalString("CreateOperation")
3827		case "hash":
3828			out.Values[i] = ec._CreateOperation_hash(ctx, field, obj)
3829			if out.Values[i] == graphql.Null {
3830				invalid = true
3831			}
3832		case "author":
3833			out.Values[i] = ec._CreateOperation_author(ctx, field, obj)
3834			if out.Values[i] == graphql.Null {
3835				invalid = true
3836			}
3837		case "date":
3838			wg.Add(1)
3839			go func(i int, field graphql.CollectedField) {
3840				out.Values[i] = ec._CreateOperation_date(ctx, field, obj)
3841				if out.Values[i] == graphql.Null {
3842					invalid = true
3843				}
3844				wg.Done()
3845			}(i, field)
3846		case "title":
3847			out.Values[i] = ec._CreateOperation_title(ctx, field, obj)
3848			if out.Values[i] == graphql.Null {
3849				invalid = true
3850			}
3851		case "message":
3852			out.Values[i] = ec._CreateOperation_message(ctx, field, obj)
3853			if out.Values[i] == graphql.Null {
3854				invalid = true
3855			}
3856		case "files":
3857			out.Values[i] = ec._CreateOperation_files(ctx, field, obj)
3858			if out.Values[i] == graphql.Null {
3859				invalid = true
3860			}
3861		default:
3862			panic("unknown field " + strconv.Quote(field.Name))
3863		}
3864	}
3865	wg.Wait()
3866	if invalid {
3867		return graphql.Null
3868	}
3869	return out
3870}
3871
3872// nolint: vetshadow
3873func (ec *executionContext) _CreateOperation_hash(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) graphql.Marshaler {
3874	ctx = ec.Tracer.StartFieldExecution(ctx, field)
3875	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3876	rctx := &graphql.ResolverContext{
3877		Object: "CreateOperation",
3878		Args:   nil,
3879		Field:  field,
3880	}
3881	ctx = graphql.WithResolverContext(ctx, rctx)
3882	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3883	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3884		ctx = rctx // use context from middleware stack in children
3885		return obj.Hash()
3886	})
3887	if resTmp == nil {
3888		if !ec.HasError(rctx) {
3889			ec.Errorf(ctx, "must not be null")
3890		}
3891		return graphql.Null
3892	}
3893	res := resTmp.(git.Hash)
3894	rctx.Result = res
3895	ctx = ec.Tracer.StartFieldChildExecution(ctx)
3896	return res
3897}
3898
3899// nolint: vetshadow
3900func (ec *executionContext) _CreateOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) graphql.Marshaler {
3901	ctx = ec.Tracer.StartFieldExecution(ctx, field)
3902	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3903	rctx := &graphql.ResolverContext{
3904		Object: "CreateOperation",
3905		Args:   nil,
3906		Field:  field,
3907	}
3908	ctx = graphql.WithResolverContext(ctx, rctx)
3909	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3910	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3911		ctx = rctx // use context from middleware stack in children
3912		return obj.Author, nil
3913	})
3914	if resTmp == nil {
3915		if !ec.HasError(rctx) {
3916			ec.Errorf(ctx, "must not be null")
3917		}
3918		return graphql.Null
3919	}
3920	res := resTmp.(identity.Interface)
3921	rctx.Result = res
3922	ctx = ec.Tracer.StartFieldChildExecution(ctx)
3923
3924	return ec._Identity(ctx, field.Selections, &res)
3925}
3926
3927// nolint: vetshadow
3928func (ec *executionContext) _CreateOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) graphql.Marshaler {
3929	ctx = ec.Tracer.StartFieldExecution(ctx, field)
3930	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3931	rctx := &graphql.ResolverContext{
3932		Object: "CreateOperation",
3933		Args:   nil,
3934		Field:  field,
3935	}
3936	ctx = graphql.WithResolverContext(ctx, rctx)
3937	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3938	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3939		ctx = rctx // use context from middleware stack in children
3940		return ec.resolvers.CreateOperation().Date(rctx, obj)
3941	})
3942	if resTmp == nil {
3943		if !ec.HasError(rctx) {
3944			ec.Errorf(ctx, "must not be null")
3945		}
3946		return graphql.Null
3947	}
3948	res := resTmp.(time.Time)
3949	rctx.Result = res
3950	ctx = ec.Tracer.StartFieldChildExecution(ctx)
3951	return graphql.MarshalTime(res)
3952}
3953
3954// nolint: vetshadow
3955func (ec *executionContext) _CreateOperation_title(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) graphql.Marshaler {
3956	ctx = ec.Tracer.StartFieldExecution(ctx, field)
3957	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3958	rctx := &graphql.ResolverContext{
3959		Object: "CreateOperation",
3960		Args:   nil,
3961		Field:  field,
3962	}
3963	ctx = graphql.WithResolverContext(ctx, rctx)
3964	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3965	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3966		ctx = rctx // use context from middleware stack in children
3967		return obj.Title, nil
3968	})
3969	if resTmp == nil {
3970		if !ec.HasError(rctx) {
3971			ec.Errorf(ctx, "must not be null")
3972		}
3973		return graphql.Null
3974	}
3975	res := resTmp.(string)
3976	rctx.Result = res
3977	ctx = ec.Tracer.StartFieldChildExecution(ctx)
3978	return graphql.MarshalString(res)
3979}
3980
3981// nolint: vetshadow
3982func (ec *executionContext) _CreateOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) graphql.Marshaler {
3983	ctx = ec.Tracer.StartFieldExecution(ctx, field)
3984	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
3985	rctx := &graphql.ResolverContext{
3986		Object: "CreateOperation",
3987		Args:   nil,
3988		Field:  field,
3989	}
3990	ctx = graphql.WithResolverContext(ctx, rctx)
3991	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
3992	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
3993		ctx = rctx // use context from middleware stack in children
3994		return obj.Message, nil
3995	})
3996	if resTmp == nil {
3997		if !ec.HasError(rctx) {
3998			ec.Errorf(ctx, "must not be null")
3999		}
4000		return graphql.Null
4001	}
4002	res := resTmp.(string)
4003	rctx.Result = res
4004	ctx = ec.Tracer.StartFieldChildExecution(ctx)
4005	return graphql.MarshalString(res)
4006}
4007
4008// nolint: vetshadow
4009func (ec *executionContext) _CreateOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) graphql.Marshaler {
4010	ctx = ec.Tracer.StartFieldExecution(ctx, field)
4011	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4012	rctx := &graphql.ResolverContext{
4013		Object: "CreateOperation",
4014		Args:   nil,
4015		Field:  field,
4016	}
4017	ctx = graphql.WithResolverContext(ctx, rctx)
4018	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4019	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4020		ctx = rctx // use context from middleware stack in children
4021		return obj.Files, nil
4022	})
4023	if resTmp == nil {
4024		if !ec.HasError(rctx) {
4025			ec.Errorf(ctx, "must not be null")
4026		}
4027		return graphql.Null
4028	}
4029	res := resTmp.([]git.Hash)
4030	rctx.Result = res
4031	ctx = ec.Tracer.StartFieldChildExecution(ctx)
4032
4033	arr1 := make(graphql.Array, len(res))
4034
4035	for idx1 := range res {
4036		arr1[idx1] = func() graphql.Marshaler {
4037			return res[idx1]
4038		}()
4039	}
4040
4041	return arr1
4042}
4043
4044var createTimelineItemImplementors = []string{"CreateTimelineItem", "TimelineItem"}
4045
4046// nolint: gocyclo, errcheck, gas, goconst
4047func (ec *executionContext) _CreateTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.CreateTimelineItem) graphql.Marshaler {
4048	fields := graphql.CollectFields(ctx, sel, createTimelineItemImplementors)
4049
4050	var wg sync.WaitGroup
4051	out := graphql.NewOrderedMap(len(fields))
4052	invalid := false
4053	for i, field := range fields {
4054		out.Keys[i] = field.Alias
4055
4056		switch field.Name {
4057		case "__typename":
4058			out.Values[i] = graphql.MarshalString("CreateTimelineItem")
4059		case "hash":
4060			out.Values[i] = ec._CreateTimelineItem_hash(ctx, field, obj)
4061			if out.Values[i] == graphql.Null {
4062				invalid = true
4063			}
4064		case "author":
4065			out.Values[i] = ec._CreateTimelineItem_author(ctx, field, obj)
4066			if out.Values[i] == graphql.Null {
4067				invalid = true
4068			}
4069		case "message":
4070			out.Values[i] = ec._CreateTimelineItem_message(ctx, field, obj)
4071			if out.Values[i] == graphql.Null {
4072				invalid = true
4073			}
4074		case "messageIsEmpty":
4075			out.Values[i] = ec._CreateTimelineItem_messageIsEmpty(ctx, field, obj)
4076			if out.Values[i] == graphql.Null {
4077				invalid = true
4078			}
4079		case "files":
4080			out.Values[i] = ec._CreateTimelineItem_files(ctx, field, obj)
4081			if out.Values[i] == graphql.Null {
4082				invalid = true
4083			}
4084		case "createdAt":
4085			wg.Add(1)
4086			go func(i int, field graphql.CollectedField) {
4087				out.Values[i] = ec._CreateTimelineItem_createdAt(ctx, field, obj)
4088				if out.Values[i] == graphql.Null {
4089					invalid = true
4090				}
4091				wg.Done()
4092			}(i, field)
4093		case "lastEdit":
4094			wg.Add(1)
4095			go func(i int, field graphql.CollectedField) {
4096				out.Values[i] = ec._CreateTimelineItem_lastEdit(ctx, field, obj)
4097				if out.Values[i] == graphql.Null {
4098					invalid = true
4099				}
4100				wg.Done()
4101			}(i, field)
4102		case "edited":
4103			out.Values[i] = ec._CreateTimelineItem_edited(ctx, field, obj)
4104			if out.Values[i] == graphql.Null {
4105				invalid = true
4106			}
4107		case "history":
4108			out.Values[i] = ec._CreateTimelineItem_history(ctx, field, obj)
4109			if out.Values[i] == graphql.Null {
4110				invalid = true
4111			}
4112		default:
4113			panic("unknown field " + strconv.Quote(field.Name))
4114		}
4115	}
4116	wg.Wait()
4117	if invalid {
4118		return graphql.Null
4119	}
4120	return out
4121}
4122
4123// nolint: vetshadow
4124func (ec *executionContext) _CreateTimelineItem_hash(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) graphql.Marshaler {
4125	ctx = ec.Tracer.StartFieldExecution(ctx, field)
4126	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4127	rctx := &graphql.ResolverContext{
4128		Object: "CreateTimelineItem",
4129		Args:   nil,
4130		Field:  field,
4131	}
4132	ctx = graphql.WithResolverContext(ctx, rctx)
4133	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4134	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4135		ctx = rctx // use context from middleware stack in children
4136		return obj.Hash(), nil
4137	})
4138	if resTmp == nil {
4139		if !ec.HasError(rctx) {
4140			ec.Errorf(ctx, "must not be null")
4141		}
4142		return graphql.Null
4143	}
4144	res := resTmp.(git.Hash)
4145	rctx.Result = res
4146	ctx = ec.Tracer.StartFieldChildExecution(ctx)
4147	return res
4148}
4149
4150// nolint: vetshadow
4151func (ec *executionContext) _CreateTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) graphql.Marshaler {
4152	ctx = ec.Tracer.StartFieldExecution(ctx, field)
4153	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4154	rctx := &graphql.ResolverContext{
4155		Object: "CreateTimelineItem",
4156		Args:   nil,
4157		Field:  field,
4158	}
4159	ctx = graphql.WithResolverContext(ctx, rctx)
4160	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4161	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4162		ctx = rctx // use context from middleware stack in children
4163		return obj.Author, nil
4164	})
4165	if resTmp == nil {
4166		if !ec.HasError(rctx) {
4167			ec.Errorf(ctx, "must not be null")
4168		}
4169		return graphql.Null
4170	}
4171	res := resTmp.(identity.Interface)
4172	rctx.Result = res
4173	ctx = ec.Tracer.StartFieldChildExecution(ctx)
4174
4175	return ec._Identity(ctx, field.Selections, &res)
4176}
4177
4178// nolint: vetshadow
4179func (ec *executionContext) _CreateTimelineItem_message(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) graphql.Marshaler {
4180	ctx = ec.Tracer.StartFieldExecution(ctx, field)
4181	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4182	rctx := &graphql.ResolverContext{
4183		Object: "CreateTimelineItem",
4184		Args:   nil,
4185		Field:  field,
4186	}
4187	ctx = graphql.WithResolverContext(ctx, rctx)
4188	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4189	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4190		ctx = rctx // use context from middleware stack in children
4191		return obj.Message, nil
4192	})
4193	if resTmp == nil {
4194		if !ec.HasError(rctx) {
4195			ec.Errorf(ctx, "must not be null")
4196		}
4197		return graphql.Null
4198	}
4199	res := resTmp.(string)
4200	rctx.Result = res
4201	ctx = ec.Tracer.StartFieldChildExecution(ctx)
4202	return graphql.MarshalString(res)
4203}
4204
4205// nolint: vetshadow
4206func (ec *executionContext) _CreateTimelineItem_messageIsEmpty(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) graphql.Marshaler {
4207	ctx = ec.Tracer.StartFieldExecution(ctx, field)
4208	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4209	rctx := &graphql.ResolverContext{
4210		Object: "CreateTimelineItem",
4211		Args:   nil,
4212		Field:  field,
4213	}
4214	ctx = graphql.WithResolverContext(ctx, rctx)
4215	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4216	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4217		ctx = rctx // use context from middleware stack in children
4218		return obj.MessageIsEmpty(), nil
4219	})
4220	if resTmp == nil {
4221		if !ec.HasError(rctx) {
4222			ec.Errorf(ctx, "must not be null")
4223		}
4224		return graphql.Null
4225	}
4226	res := resTmp.(bool)
4227	rctx.Result = res
4228	ctx = ec.Tracer.StartFieldChildExecution(ctx)
4229	return graphql.MarshalBoolean(res)
4230}
4231
4232// nolint: vetshadow
4233func (ec *executionContext) _CreateTimelineItem_files(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) graphql.Marshaler {
4234	ctx = ec.Tracer.StartFieldExecution(ctx, field)
4235	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4236	rctx := &graphql.ResolverContext{
4237		Object: "CreateTimelineItem",
4238		Args:   nil,
4239		Field:  field,
4240	}
4241	ctx = graphql.WithResolverContext(ctx, rctx)
4242	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4243	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4244		ctx = rctx // use context from middleware stack in children
4245		return obj.Files, nil
4246	})
4247	if resTmp == nil {
4248		if !ec.HasError(rctx) {
4249			ec.Errorf(ctx, "must not be null")
4250		}
4251		return graphql.Null
4252	}
4253	res := resTmp.([]git.Hash)
4254	rctx.Result = res
4255	ctx = ec.Tracer.StartFieldChildExecution(ctx)
4256
4257	arr1 := make(graphql.Array, len(res))
4258
4259	for idx1 := range res {
4260		arr1[idx1] = func() graphql.Marshaler {
4261			return res[idx1]
4262		}()
4263	}
4264
4265	return arr1
4266}
4267
4268// nolint: vetshadow
4269func (ec *executionContext) _CreateTimelineItem_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) graphql.Marshaler {
4270	ctx = ec.Tracer.StartFieldExecution(ctx, field)
4271	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4272	rctx := &graphql.ResolverContext{
4273		Object: "CreateTimelineItem",
4274		Args:   nil,
4275		Field:  field,
4276	}
4277	ctx = graphql.WithResolverContext(ctx, rctx)
4278	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4279	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4280		ctx = rctx // use context from middleware stack in children
4281		return ec.resolvers.CreateTimelineItem().CreatedAt(rctx, obj)
4282	})
4283	if resTmp == nil {
4284		if !ec.HasError(rctx) {
4285			ec.Errorf(ctx, "must not be null")
4286		}
4287		return graphql.Null
4288	}
4289	res := resTmp.(time.Time)
4290	rctx.Result = res
4291	ctx = ec.Tracer.StartFieldChildExecution(ctx)
4292	return graphql.MarshalTime(res)
4293}
4294
4295// nolint: vetshadow
4296func (ec *executionContext) _CreateTimelineItem_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) graphql.Marshaler {
4297	ctx = ec.Tracer.StartFieldExecution(ctx, field)
4298	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4299	rctx := &graphql.ResolverContext{
4300		Object: "CreateTimelineItem",
4301		Args:   nil,
4302		Field:  field,
4303	}
4304	ctx = graphql.WithResolverContext(ctx, rctx)
4305	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4306	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4307		ctx = rctx // use context from middleware stack in children
4308		return ec.resolvers.CreateTimelineItem().LastEdit(rctx, obj)
4309	})
4310	if resTmp == nil {
4311		if !ec.HasError(rctx) {
4312			ec.Errorf(ctx, "must not be null")
4313		}
4314		return graphql.Null
4315	}
4316	res := resTmp.(time.Time)
4317	rctx.Result = res
4318	ctx = ec.Tracer.StartFieldChildExecution(ctx)
4319	return graphql.MarshalTime(res)
4320}
4321
4322// nolint: vetshadow
4323func (ec *executionContext) _CreateTimelineItem_edited(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) graphql.Marshaler {
4324	ctx = ec.Tracer.StartFieldExecution(ctx, field)
4325	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4326	rctx := &graphql.ResolverContext{
4327		Object: "CreateTimelineItem",
4328		Args:   nil,
4329		Field:  field,
4330	}
4331	ctx = graphql.WithResolverContext(ctx, rctx)
4332	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4333	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4334		ctx = rctx // use context from middleware stack in children
4335		return obj.Edited(), nil
4336	})
4337	if resTmp == nil {
4338		if !ec.HasError(rctx) {
4339			ec.Errorf(ctx, "must not be null")
4340		}
4341		return graphql.Null
4342	}
4343	res := resTmp.(bool)
4344	rctx.Result = res
4345	ctx = ec.Tracer.StartFieldChildExecution(ctx)
4346	return graphql.MarshalBoolean(res)
4347}
4348
4349// nolint: vetshadow
4350func (ec *executionContext) _CreateTimelineItem_history(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) graphql.Marshaler {
4351	ctx = ec.Tracer.StartFieldExecution(ctx, field)
4352	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4353	rctx := &graphql.ResolverContext{
4354		Object: "CreateTimelineItem",
4355		Args:   nil,
4356		Field:  field,
4357	}
4358	ctx = graphql.WithResolverContext(ctx, rctx)
4359	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4360	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4361		ctx = rctx // use context from middleware stack in children
4362		return obj.History, nil
4363	})
4364	if resTmp == nil {
4365		if !ec.HasError(rctx) {
4366			ec.Errorf(ctx, "must not be null")
4367		}
4368		return graphql.Null
4369	}
4370	res := resTmp.([]bug.CommentHistoryStep)
4371	rctx.Result = res
4372	ctx = ec.Tracer.StartFieldChildExecution(ctx)
4373
4374	arr1 := make(graphql.Array, len(res))
4375	var wg sync.WaitGroup
4376
4377	isLen1 := len(res) == 1
4378	if !isLen1 {
4379		wg.Add(len(res))
4380	}
4381
4382	for idx1 := range res {
4383		idx1 := idx1
4384		rctx := &graphql.ResolverContext{
4385			Index:  &idx1,
4386			Result: &res[idx1],
4387		}
4388		ctx := graphql.WithResolverContext(ctx, rctx)
4389		f := func(idx1 int) {
4390			if !isLen1 {
4391				defer wg.Done()
4392			}
4393			arr1[idx1] = func() graphql.Marshaler {
4394
4395				return ec._CommentHistoryStep(ctx, field.Selections, &res[idx1])
4396			}()
4397		}
4398		if isLen1 {
4399			f(idx1)
4400		} else {
4401			go f(idx1)
4402		}
4403
4404	}
4405	wg.Wait()
4406	return arr1
4407}
4408
4409var editCommentOperationImplementors = []string{"EditCommentOperation", "Operation", "Authored"}
4410
4411// nolint: gocyclo, errcheck, gas, goconst
4412func (ec *executionContext) _EditCommentOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.EditCommentOperation) graphql.Marshaler {
4413	fields := graphql.CollectFields(ctx, sel, editCommentOperationImplementors)
4414
4415	var wg sync.WaitGroup
4416	out := graphql.NewOrderedMap(len(fields))
4417	invalid := false
4418	for i, field := range fields {
4419		out.Keys[i] = field.Alias
4420
4421		switch field.Name {
4422		case "__typename":
4423			out.Values[i] = graphql.MarshalString("EditCommentOperation")
4424		case "hash":
4425			out.Values[i] = ec._EditCommentOperation_hash(ctx, field, obj)
4426			if out.Values[i] == graphql.Null {
4427				invalid = true
4428			}
4429		case "author":
4430			out.Values[i] = ec._EditCommentOperation_author(ctx, field, obj)
4431			if out.Values[i] == graphql.Null {
4432				invalid = true
4433			}
4434		case "date":
4435			wg.Add(1)
4436			go func(i int, field graphql.CollectedField) {
4437				out.Values[i] = ec._EditCommentOperation_date(ctx, field, obj)
4438				if out.Values[i] == graphql.Null {
4439					invalid = true
4440				}
4441				wg.Done()
4442			}(i, field)
4443		case "target":
4444			out.Values[i] = ec._EditCommentOperation_target(ctx, field, obj)
4445			if out.Values[i] == graphql.Null {
4446				invalid = true
4447			}
4448		case "message":
4449			out.Values[i] = ec._EditCommentOperation_message(ctx, field, obj)
4450			if out.Values[i] == graphql.Null {
4451				invalid = true
4452			}
4453		case "files":
4454			out.Values[i] = ec._EditCommentOperation_files(ctx, field, obj)
4455			if out.Values[i] == graphql.Null {
4456				invalid = true
4457			}
4458		default:
4459			panic("unknown field " + strconv.Quote(field.Name))
4460		}
4461	}
4462	wg.Wait()
4463	if invalid {
4464		return graphql.Null
4465	}
4466	return out
4467}
4468
4469// nolint: vetshadow
4470func (ec *executionContext) _EditCommentOperation_hash(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) graphql.Marshaler {
4471	ctx = ec.Tracer.StartFieldExecution(ctx, field)
4472	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4473	rctx := &graphql.ResolverContext{
4474		Object: "EditCommentOperation",
4475		Args:   nil,
4476		Field:  field,
4477	}
4478	ctx = graphql.WithResolverContext(ctx, rctx)
4479	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4480	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4481		ctx = rctx // use context from middleware stack in children
4482		return obj.Hash()
4483	})
4484	if resTmp == nil {
4485		if !ec.HasError(rctx) {
4486			ec.Errorf(ctx, "must not be null")
4487		}
4488		return graphql.Null
4489	}
4490	res := resTmp.(git.Hash)
4491	rctx.Result = res
4492	ctx = ec.Tracer.StartFieldChildExecution(ctx)
4493	return res
4494}
4495
4496// nolint: vetshadow
4497func (ec *executionContext) _EditCommentOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) graphql.Marshaler {
4498	ctx = ec.Tracer.StartFieldExecution(ctx, field)
4499	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4500	rctx := &graphql.ResolverContext{
4501		Object: "EditCommentOperation",
4502		Args:   nil,
4503		Field:  field,
4504	}
4505	ctx = graphql.WithResolverContext(ctx, rctx)
4506	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4507	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4508		ctx = rctx // use context from middleware stack in children
4509		return obj.Author, nil
4510	})
4511	if resTmp == nil {
4512		if !ec.HasError(rctx) {
4513			ec.Errorf(ctx, "must not be null")
4514		}
4515		return graphql.Null
4516	}
4517	res := resTmp.(identity.Interface)
4518	rctx.Result = res
4519	ctx = ec.Tracer.StartFieldChildExecution(ctx)
4520
4521	return ec._Identity(ctx, field.Selections, &res)
4522}
4523
4524// nolint: vetshadow
4525func (ec *executionContext) _EditCommentOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) graphql.Marshaler {
4526	ctx = ec.Tracer.StartFieldExecution(ctx, field)
4527	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4528	rctx := &graphql.ResolverContext{
4529		Object: "EditCommentOperation",
4530		Args:   nil,
4531		Field:  field,
4532	}
4533	ctx = graphql.WithResolverContext(ctx, rctx)
4534	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4535	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4536		ctx = rctx // use context from middleware stack in children
4537		return ec.resolvers.EditCommentOperation().Date(rctx, obj)
4538	})
4539	if resTmp == nil {
4540		if !ec.HasError(rctx) {
4541			ec.Errorf(ctx, "must not be null")
4542		}
4543		return graphql.Null
4544	}
4545	res := resTmp.(time.Time)
4546	rctx.Result = res
4547	ctx = ec.Tracer.StartFieldChildExecution(ctx)
4548	return graphql.MarshalTime(res)
4549}
4550
4551// nolint: vetshadow
4552func (ec *executionContext) _EditCommentOperation_target(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) graphql.Marshaler {
4553	ctx = ec.Tracer.StartFieldExecution(ctx, field)
4554	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4555	rctx := &graphql.ResolverContext{
4556		Object: "EditCommentOperation",
4557		Args:   nil,
4558		Field:  field,
4559	}
4560	ctx = graphql.WithResolverContext(ctx, rctx)
4561	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4562	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4563		ctx = rctx // use context from middleware stack in children
4564		return obj.Target, nil
4565	})
4566	if resTmp == nil {
4567		if !ec.HasError(rctx) {
4568			ec.Errorf(ctx, "must not be null")
4569		}
4570		return graphql.Null
4571	}
4572	res := resTmp.(git.Hash)
4573	rctx.Result = res
4574	ctx = ec.Tracer.StartFieldChildExecution(ctx)
4575	return res
4576}
4577
4578// nolint: vetshadow
4579func (ec *executionContext) _EditCommentOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) graphql.Marshaler {
4580	ctx = ec.Tracer.StartFieldExecution(ctx, field)
4581	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4582	rctx := &graphql.ResolverContext{
4583		Object: "EditCommentOperation",
4584		Args:   nil,
4585		Field:  field,
4586	}
4587	ctx = graphql.WithResolverContext(ctx, rctx)
4588	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4589	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4590		ctx = rctx // use context from middleware stack in children
4591		return obj.Message, nil
4592	})
4593	if resTmp == nil {
4594		if !ec.HasError(rctx) {
4595			ec.Errorf(ctx, "must not be null")
4596		}
4597		return graphql.Null
4598	}
4599	res := resTmp.(string)
4600	rctx.Result = res
4601	ctx = ec.Tracer.StartFieldChildExecution(ctx)
4602	return graphql.MarshalString(res)
4603}
4604
4605// nolint: vetshadow
4606func (ec *executionContext) _EditCommentOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) graphql.Marshaler {
4607	ctx = ec.Tracer.StartFieldExecution(ctx, field)
4608	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4609	rctx := &graphql.ResolverContext{
4610		Object: "EditCommentOperation",
4611		Args:   nil,
4612		Field:  field,
4613	}
4614	ctx = graphql.WithResolverContext(ctx, rctx)
4615	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4616	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4617		ctx = rctx // use context from middleware stack in children
4618		return obj.Files, nil
4619	})
4620	if resTmp == nil {
4621		if !ec.HasError(rctx) {
4622			ec.Errorf(ctx, "must not be null")
4623		}
4624		return graphql.Null
4625	}
4626	res := resTmp.([]git.Hash)
4627	rctx.Result = res
4628	ctx = ec.Tracer.StartFieldChildExecution(ctx)
4629
4630	arr1 := make(graphql.Array, len(res))
4631
4632	for idx1 := range res {
4633		arr1[idx1] = func() graphql.Marshaler {
4634			return res[idx1]
4635		}()
4636	}
4637
4638	return arr1
4639}
4640
4641var identityImplementors = []string{"Identity"}
4642
4643// nolint: gocyclo, errcheck, gas, goconst
4644func (ec *executionContext) _Identity(ctx context.Context, sel ast.SelectionSet, obj *identity.Interface) graphql.Marshaler {
4645	fields := graphql.CollectFields(ctx, sel, identityImplementors)
4646
4647	var wg sync.WaitGroup
4648	out := graphql.NewOrderedMap(len(fields))
4649	invalid := false
4650	for i, field := range fields {
4651		out.Keys[i] = field.Alias
4652
4653		switch field.Name {
4654		case "__typename":
4655			out.Values[i] = graphql.MarshalString("Identity")
4656		case "name":
4657			wg.Add(1)
4658			go func(i int, field graphql.CollectedField) {
4659				out.Values[i] = ec._Identity_name(ctx, field, obj)
4660				wg.Done()
4661			}(i, field)
4662		case "email":
4663			wg.Add(1)
4664			go func(i int, field graphql.CollectedField) {
4665				out.Values[i] = ec._Identity_email(ctx, field, obj)
4666				wg.Done()
4667			}(i, field)
4668		case "login":
4669			wg.Add(1)
4670			go func(i int, field graphql.CollectedField) {
4671				out.Values[i] = ec._Identity_login(ctx, field, obj)
4672				wg.Done()
4673			}(i, field)
4674		case "displayName":
4675			wg.Add(1)
4676			go func(i int, field graphql.CollectedField) {
4677				out.Values[i] = ec._Identity_displayName(ctx, field, obj)
4678				if out.Values[i] == graphql.Null {
4679					invalid = true
4680				}
4681				wg.Done()
4682			}(i, field)
4683		case "avatarUrl":
4684			wg.Add(1)
4685			go func(i int, field graphql.CollectedField) {
4686				out.Values[i] = ec._Identity_avatarUrl(ctx, field, obj)
4687				wg.Done()
4688			}(i, field)
4689		default:
4690			panic("unknown field " + strconv.Quote(field.Name))
4691		}
4692	}
4693	wg.Wait()
4694	if invalid {
4695		return graphql.Null
4696	}
4697	return out
4698}
4699
4700// nolint: vetshadow
4701func (ec *executionContext) _Identity_name(ctx context.Context, field graphql.CollectedField, obj *identity.Interface) graphql.Marshaler {
4702	ctx = ec.Tracer.StartFieldExecution(ctx, field)
4703	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4704	rctx := &graphql.ResolverContext{
4705		Object: "Identity",
4706		Args:   nil,
4707		Field:  field,
4708	}
4709	ctx = graphql.WithResolverContext(ctx, rctx)
4710	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4711	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4712		ctx = rctx // use context from middleware stack in children
4713		return ec.resolvers.Identity().Name(rctx, obj)
4714	})
4715	if resTmp == nil {
4716		return graphql.Null
4717	}
4718	res := resTmp.(*string)
4719	rctx.Result = res
4720	ctx = ec.Tracer.StartFieldChildExecution(ctx)
4721
4722	if res == nil {
4723		return graphql.Null
4724	}
4725	return graphql.MarshalString(*res)
4726}
4727
4728// nolint: vetshadow
4729func (ec *executionContext) _Identity_email(ctx context.Context, field graphql.CollectedField, obj *identity.Interface) graphql.Marshaler {
4730	ctx = ec.Tracer.StartFieldExecution(ctx, field)
4731	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4732	rctx := &graphql.ResolverContext{
4733		Object: "Identity",
4734		Args:   nil,
4735		Field:  field,
4736	}
4737	ctx = graphql.WithResolverContext(ctx, rctx)
4738	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4739	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4740		ctx = rctx // use context from middleware stack in children
4741		return ec.resolvers.Identity().Email(rctx, obj)
4742	})
4743	if resTmp == nil {
4744		return graphql.Null
4745	}
4746	res := resTmp.(*string)
4747	rctx.Result = res
4748	ctx = ec.Tracer.StartFieldChildExecution(ctx)
4749
4750	if res == nil {
4751		return graphql.Null
4752	}
4753	return graphql.MarshalString(*res)
4754}
4755
4756// nolint: vetshadow
4757func (ec *executionContext) _Identity_login(ctx context.Context, field graphql.CollectedField, obj *identity.Interface) graphql.Marshaler {
4758	ctx = ec.Tracer.StartFieldExecution(ctx, field)
4759	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4760	rctx := &graphql.ResolverContext{
4761		Object: "Identity",
4762		Args:   nil,
4763		Field:  field,
4764	}
4765	ctx = graphql.WithResolverContext(ctx, rctx)
4766	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4767	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4768		ctx = rctx // use context from middleware stack in children
4769		return ec.resolvers.Identity().Login(rctx, obj)
4770	})
4771	if resTmp == nil {
4772		return graphql.Null
4773	}
4774	res := resTmp.(*string)
4775	rctx.Result = res
4776	ctx = ec.Tracer.StartFieldChildExecution(ctx)
4777
4778	if res == nil {
4779		return graphql.Null
4780	}
4781	return graphql.MarshalString(*res)
4782}
4783
4784// nolint: vetshadow
4785func (ec *executionContext) _Identity_displayName(ctx context.Context, field graphql.CollectedField, obj *identity.Interface) graphql.Marshaler {
4786	ctx = ec.Tracer.StartFieldExecution(ctx, field)
4787	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4788	rctx := &graphql.ResolverContext{
4789		Object: "Identity",
4790		Args:   nil,
4791		Field:  field,
4792	}
4793	ctx = graphql.WithResolverContext(ctx, rctx)
4794	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4795	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4796		ctx = rctx // use context from middleware stack in children
4797		return ec.resolvers.Identity().DisplayName(rctx, obj)
4798	})
4799	if resTmp == nil {
4800		if !ec.HasError(rctx) {
4801			ec.Errorf(ctx, "must not be null")
4802		}
4803		return graphql.Null
4804	}
4805	res := resTmp.(string)
4806	rctx.Result = res
4807	ctx = ec.Tracer.StartFieldChildExecution(ctx)
4808	return graphql.MarshalString(res)
4809}
4810
4811// nolint: vetshadow
4812func (ec *executionContext) _Identity_avatarUrl(ctx context.Context, field graphql.CollectedField, obj *identity.Interface) graphql.Marshaler {
4813	ctx = ec.Tracer.StartFieldExecution(ctx, field)
4814	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4815	rctx := &graphql.ResolverContext{
4816		Object: "Identity",
4817		Args:   nil,
4818		Field:  field,
4819	}
4820	ctx = graphql.WithResolverContext(ctx, rctx)
4821	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4822	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4823		ctx = rctx // use context from middleware stack in children
4824		return ec.resolvers.Identity().AvatarURL(rctx, obj)
4825	})
4826	if resTmp == nil {
4827		return graphql.Null
4828	}
4829	res := resTmp.(*string)
4830	rctx.Result = res
4831	ctx = ec.Tracer.StartFieldChildExecution(ctx)
4832
4833	if res == nil {
4834		return graphql.Null
4835	}
4836	return graphql.MarshalString(*res)
4837}
4838
4839var labelChangeOperationImplementors = []string{"LabelChangeOperation", "Operation", "Authored"}
4840
4841// nolint: gocyclo, errcheck, gas, goconst
4842func (ec *executionContext) _LabelChangeOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeOperation) graphql.Marshaler {
4843	fields := graphql.CollectFields(ctx, sel, labelChangeOperationImplementors)
4844
4845	var wg sync.WaitGroup
4846	out := graphql.NewOrderedMap(len(fields))
4847	invalid := false
4848	for i, field := range fields {
4849		out.Keys[i] = field.Alias
4850
4851		switch field.Name {
4852		case "__typename":
4853			out.Values[i] = graphql.MarshalString("LabelChangeOperation")
4854		case "hash":
4855			out.Values[i] = ec._LabelChangeOperation_hash(ctx, field, obj)
4856			if out.Values[i] == graphql.Null {
4857				invalid = true
4858			}
4859		case "author":
4860			out.Values[i] = ec._LabelChangeOperation_author(ctx, field, obj)
4861			if out.Values[i] == graphql.Null {
4862				invalid = true
4863			}
4864		case "date":
4865			wg.Add(1)
4866			go func(i int, field graphql.CollectedField) {
4867				out.Values[i] = ec._LabelChangeOperation_date(ctx, field, obj)
4868				if out.Values[i] == graphql.Null {
4869					invalid = true
4870				}
4871				wg.Done()
4872			}(i, field)
4873		case "added":
4874			out.Values[i] = ec._LabelChangeOperation_added(ctx, field, obj)
4875			if out.Values[i] == graphql.Null {
4876				invalid = true
4877			}
4878		case "removed":
4879			out.Values[i] = ec._LabelChangeOperation_removed(ctx, field, obj)
4880			if out.Values[i] == graphql.Null {
4881				invalid = true
4882			}
4883		default:
4884			panic("unknown field " + strconv.Quote(field.Name))
4885		}
4886	}
4887	wg.Wait()
4888	if invalid {
4889		return graphql.Null
4890	}
4891	return out
4892}
4893
4894// nolint: vetshadow
4895func (ec *executionContext) _LabelChangeOperation_hash(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) graphql.Marshaler {
4896	ctx = ec.Tracer.StartFieldExecution(ctx, field)
4897	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4898	rctx := &graphql.ResolverContext{
4899		Object: "LabelChangeOperation",
4900		Args:   nil,
4901		Field:  field,
4902	}
4903	ctx = graphql.WithResolverContext(ctx, rctx)
4904	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4905	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4906		ctx = rctx // use context from middleware stack in children
4907		return obj.Hash()
4908	})
4909	if resTmp == nil {
4910		if !ec.HasError(rctx) {
4911			ec.Errorf(ctx, "must not be null")
4912		}
4913		return graphql.Null
4914	}
4915	res := resTmp.(git.Hash)
4916	rctx.Result = res
4917	ctx = ec.Tracer.StartFieldChildExecution(ctx)
4918	return res
4919}
4920
4921// nolint: vetshadow
4922func (ec *executionContext) _LabelChangeOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) graphql.Marshaler {
4923	ctx = ec.Tracer.StartFieldExecution(ctx, field)
4924	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4925	rctx := &graphql.ResolverContext{
4926		Object: "LabelChangeOperation",
4927		Args:   nil,
4928		Field:  field,
4929	}
4930	ctx = graphql.WithResolverContext(ctx, rctx)
4931	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4932	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4933		ctx = rctx // use context from middleware stack in children
4934		return obj.Author, nil
4935	})
4936	if resTmp == nil {
4937		if !ec.HasError(rctx) {
4938			ec.Errorf(ctx, "must not be null")
4939		}
4940		return graphql.Null
4941	}
4942	res := resTmp.(identity.Interface)
4943	rctx.Result = res
4944	ctx = ec.Tracer.StartFieldChildExecution(ctx)
4945
4946	return ec._Identity(ctx, field.Selections, &res)
4947}
4948
4949// nolint: vetshadow
4950func (ec *executionContext) _LabelChangeOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) graphql.Marshaler {
4951	ctx = ec.Tracer.StartFieldExecution(ctx, field)
4952	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4953	rctx := &graphql.ResolverContext{
4954		Object: "LabelChangeOperation",
4955		Args:   nil,
4956		Field:  field,
4957	}
4958	ctx = graphql.WithResolverContext(ctx, rctx)
4959	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4960	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4961		ctx = rctx // use context from middleware stack in children
4962		return ec.resolvers.LabelChangeOperation().Date(rctx, obj)
4963	})
4964	if resTmp == nil {
4965		if !ec.HasError(rctx) {
4966			ec.Errorf(ctx, "must not be null")
4967		}
4968		return graphql.Null
4969	}
4970	res := resTmp.(time.Time)
4971	rctx.Result = res
4972	ctx = ec.Tracer.StartFieldChildExecution(ctx)
4973	return graphql.MarshalTime(res)
4974}
4975
4976// nolint: vetshadow
4977func (ec *executionContext) _LabelChangeOperation_added(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) graphql.Marshaler {
4978	ctx = ec.Tracer.StartFieldExecution(ctx, field)
4979	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
4980	rctx := &graphql.ResolverContext{
4981		Object: "LabelChangeOperation",
4982		Args:   nil,
4983		Field:  field,
4984	}
4985	ctx = graphql.WithResolverContext(ctx, rctx)
4986	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
4987	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
4988		ctx = rctx // use context from middleware stack in children
4989		return obj.Added, nil
4990	})
4991	if resTmp == nil {
4992		if !ec.HasError(rctx) {
4993			ec.Errorf(ctx, "must not be null")
4994		}
4995		return graphql.Null
4996	}
4997	res := resTmp.([]bug.Label)
4998	rctx.Result = res
4999	ctx = ec.Tracer.StartFieldChildExecution(ctx)
5000
5001	arr1 := make(graphql.Array, len(res))
5002
5003	for idx1 := range res {
5004		arr1[idx1] = func() graphql.Marshaler {
5005			return res[idx1]
5006		}()
5007	}
5008
5009	return arr1
5010}
5011
5012// nolint: vetshadow
5013func (ec *executionContext) _LabelChangeOperation_removed(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) graphql.Marshaler {
5014	ctx = ec.Tracer.StartFieldExecution(ctx, field)
5015	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5016	rctx := &graphql.ResolverContext{
5017		Object: "LabelChangeOperation",
5018		Args:   nil,
5019		Field:  field,
5020	}
5021	ctx = graphql.WithResolverContext(ctx, rctx)
5022	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5023	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5024		ctx = rctx // use context from middleware stack in children
5025		return obj.Removed, nil
5026	})
5027	if resTmp == nil {
5028		if !ec.HasError(rctx) {
5029			ec.Errorf(ctx, "must not be null")
5030		}
5031		return graphql.Null
5032	}
5033	res := resTmp.([]bug.Label)
5034	rctx.Result = res
5035	ctx = ec.Tracer.StartFieldChildExecution(ctx)
5036
5037	arr1 := make(graphql.Array, len(res))
5038
5039	for idx1 := range res {
5040		arr1[idx1] = func() graphql.Marshaler {
5041			return res[idx1]
5042		}()
5043	}
5044
5045	return arr1
5046}
5047
5048var labelChangeTimelineItemImplementors = []string{"LabelChangeTimelineItem", "TimelineItem"}
5049
5050// nolint: gocyclo, errcheck, gas, goconst
5051func (ec *executionContext) _LabelChangeTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeTimelineItem) graphql.Marshaler {
5052	fields := graphql.CollectFields(ctx, sel, labelChangeTimelineItemImplementors)
5053
5054	var wg sync.WaitGroup
5055	out := graphql.NewOrderedMap(len(fields))
5056	invalid := false
5057	for i, field := range fields {
5058		out.Keys[i] = field.Alias
5059
5060		switch field.Name {
5061		case "__typename":
5062			out.Values[i] = graphql.MarshalString("LabelChangeTimelineItem")
5063		case "hash":
5064			out.Values[i] = ec._LabelChangeTimelineItem_hash(ctx, field, obj)
5065			if out.Values[i] == graphql.Null {
5066				invalid = true
5067			}
5068		case "author":
5069			out.Values[i] = ec._LabelChangeTimelineItem_author(ctx, field, obj)
5070			if out.Values[i] == graphql.Null {
5071				invalid = true
5072			}
5073		case "date":
5074			wg.Add(1)
5075			go func(i int, field graphql.CollectedField) {
5076				out.Values[i] = ec._LabelChangeTimelineItem_date(ctx, field, obj)
5077				if out.Values[i] == graphql.Null {
5078					invalid = true
5079				}
5080				wg.Done()
5081			}(i, field)
5082		case "added":
5083			out.Values[i] = ec._LabelChangeTimelineItem_added(ctx, field, obj)
5084			if out.Values[i] == graphql.Null {
5085				invalid = true
5086			}
5087		case "removed":
5088			out.Values[i] = ec._LabelChangeTimelineItem_removed(ctx, field, obj)
5089			if out.Values[i] == graphql.Null {
5090				invalid = true
5091			}
5092		default:
5093			panic("unknown field " + strconv.Quote(field.Name))
5094		}
5095	}
5096	wg.Wait()
5097	if invalid {
5098		return graphql.Null
5099	}
5100	return out
5101}
5102
5103// nolint: vetshadow
5104func (ec *executionContext) _LabelChangeTimelineItem_hash(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) graphql.Marshaler {
5105	ctx = ec.Tracer.StartFieldExecution(ctx, field)
5106	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5107	rctx := &graphql.ResolverContext{
5108		Object: "LabelChangeTimelineItem",
5109		Args:   nil,
5110		Field:  field,
5111	}
5112	ctx = graphql.WithResolverContext(ctx, rctx)
5113	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5114	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5115		ctx = rctx // use context from middleware stack in children
5116		return obj.Hash(), nil
5117	})
5118	if resTmp == nil {
5119		if !ec.HasError(rctx) {
5120			ec.Errorf(ctx, "must not be null")
5121		}
5122		return graphql.Null
5123	}
5124	res := resTmp.(git.Hash)
5125	rctx.Result = res
5126	ctx = ec.Tracer.StartFieldChildExecution(ctx)
5127	return res
5128}
5129
5130// nolint: vetshadow
5131func (ec *executionContext) _LabelChangeTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) graphql.Marshaler {
5132	ctx = ec.Tracer.StartFieldExecution(ctx, field)
5133	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5134	rctx := &graphql.ResolverContext{
5135		Object: "LabelChangeTimelineItem",
5136		Args:   nil,
5137		Field:  field,
5138	}
5139	ctx = graphql.WithResolverContext(ctx, rctx)
5140	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5141	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5142		ctx = rctx // use context from middleware stack in children
5143		return obj.Author, nil
5144	})
5145	if resTmp == nil {
5146		if !ec.HasError(rctx) {
5147			ec.Errorf(ctx, "must not be null")
5148		}
5149		return graphql.Null
5150	}
5151	res := resTmp.(identity.Interface)
5152	rctx.Result = res
5153	ctx = ec.Tracer.StartFieldChildExecution(ctx)
5154
5155	return ec._Identity(ctx, field.Selections, &res)
5156}
5157
5158// nolint: vetshadow
5159func (ec *executionContext) _LabelChangeTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) graphql.Marshaler {
5160	ctx = ec.Tracer.StartFieldExecution(ctx, field)
5161	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5162	rctx := &graphql.ResolverContext{
5163		Object: "LabelChangeTimelineItem",
5164		Args:   nil,
5165		Field:  field,
5166	}
5167	ctx = graphql.WithResolverContext(ctx, rctx)
5168	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5169	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5170		ctx = rctx // use context from middleware stack in children
5171		return ec.resolvers.LabelChangeTimelineItem().Date(rctx, obj)
5172	})
5173	if resTmp == nil {
5174		if !ec.HasError(rctx) {
5175			ec.Errorf(ctx, "must not be null")
5176		}
5177		return graphql.Null
5178	}
5179	res := resTmp.(time.Time)
5180	rctx.Result = res
5181	ctx = ec.Tracer.StartFieldChildExecution(ctx)
5182	return graphql.MarshalTime(res)
5183}
5184
5185// nolint: vetshadow
5186func (ec *executionContext) _LabelChangeTimelineItem_added(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) graphql.Marshaler {
5187	ctx = ec.Tracer.StartFieldExecution(ctx, field)
5188	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5189	rctx := &graphql.ResolverContext{
5190		Object: "LabelChangeTimelineItem",
5191		Args:   nil,
5192		Field:  field,
5193	}
5194	ctx = graphql.WithResolverContext(ctx, rctx)
5195	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5196	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5197		ctx = rctx // use context from middleware stack in children
5198		return obj.Added, nil
5199	})
5200	if resTmp == nil {
5201		if !ec.HasError(rctx) {
5202			ec.Errorf(ctx, "must not be null")
5203		}
5204		return graphql.Null
5205	}
5206	res := resTmp.([]bug.Label)
5207	rctx.Result = res
5208	ctx = ec.Tracer.StartFieldChildExecution(ctx)
5209
5210	arr1 := make(graphql.Array, len(res))
5211
5212	for idx1 := range res {
5213		arr1[idx1] = func() graphql.Marshaler {
5214			return res[idx1]
5215		}()
5216	}
5217
5218	return arr1
5219}
5220
5221// nolint: vetshadow
5222func (ec *executionContext) _LabelChangeTimelineItem_removed(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) graphql.Marshaler {
5223	ctx = ec.Tracer.StartFieldExecution(ctx, field)
5224	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5225	rctx := &graphql.ResolverContext{
5226		Object: "LabelChangeTimelineItem",
5227		Args:   nil,
5228		Field:  field,
5229	}
5230	ctx = graphql.WithResolverContext(ctx, rctx)
5231	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5232	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5233		ctx = rctx // use context from middleware stack in children
5234		return obj.Removed, nil
5235	})
5236	if resTmp == nil {
5237		if !ec.HasError(rctx) {
5238			ec.Errorf(ctx, "must not be null")
5239		}
5240		return graphql.Null
5241	}
5242	res := resTmp.([]bug.Label)
5243	rctx.Result = res
5244	ctx = ec.Tracer.StartFieldChildExecution(ctx)
5245
5246	arr1 := make(graphql.Array, len(res))
5247
5248	for idx1 := range res {
5249		arr1[idx1] = func() graphql.Marshaler {
5250			return res[idx1]
5251		}()
5252	}
5253
5254	return arr1
5255}
5256
5257var mutationImplementors = []string{"Mutation"}
5258
5259// nolint: gocyclo, errcheck, gas, goconst
5260func (ec *executionContext) _Mutation(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
5261	fields := graphql.CollectFields(ctx, sel, mutationImplementors)
5262
5263	ctx = graphql.WithResolverContext(ctx, &graphql.ResolverContext{
5264		Object: "Mutation",
5265	})
5266
5267	out := graphql.NewOrderedMap(len(fields))
5268	invalid := false
5269	for i, field := range fields {
5270		out.Keys[i] = field.Alias
5271
5272		switch field.Name {
5273		case "__typename":
5274			out.Values[i] = graphql.MarshalString("Mutation")
5275		case "newBug":
5276			out.Values[i] = ec._Mutation_newBug(ctx, field)
5277			if out.Values[i] == graphql.Null {
5278				invalid = true
5279			}
5280		case "addComment":
5281			out.Values[i] = ec._Mutation_addComment(ctx, field)
5282			if out.Values[i] == graphql.Null {
5283				invalid = true
5284			}
5285		case "changeLabels":
5286			out.Values[i] = ec._Mutation_changeLabels(ctx, field)
5287			if out.Values[i] == graphql.Null {
5288				invalid = true
5289			}
5290		case "open":
5291			out.Values[i] = ec._Mutation_open(ctx, field)
5292			if out.Values[i] == graphql.Null {
5293				invalid = true
5294			}
5295		case "close":
5296			out.Values[i] = ec._Mutation_close(ctx, field)
5297			if out.Values[i] == graphql.Null {
5298				invalid = true
5299			}
5300		case "setTitle":
5301			out.Values[i] = ec._Mutation_setTitle(ctx, field)
5302			if out.Values[i] == graphql.Null {
5303				invalid = true
5304			}
5305		case "commit":
5306			out.Values[i] = ec._Mutation_commit(ctx, field)
5307			if out.Values[i] == graphql.Null {
5308				invalid = true
5309			}
5310		default:
5311			panic("unknown field " + strconv.Quote(field.Name))
5312		}
5313	}
5314
5315	if invalid {
5316		return graphql.Null
5317	}
5318	return out
5319}
5320
5321// nolint: vetshadow
5322func (ec *executionContext) _Mutation_newBug(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
5323	ctx = ec.Tracer.StartFieldExecution(ctx, field)
5324	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5325	rawArgs := field.ArgumentMap(ec.Variables)
5326	args, err := field_Mutation_newBug_args(rawArgs)
5327	if err != nil {
5328		ec.Error(ctx, err)
5329		return graphql.Null
5330	}
5331	rctx := &graphql.ResolverContext{
5332		Object: "Mutation",
5333		Args:   args,
5334		Field:  field,
5335	}
5336	ctx = graphql.WithResolverContext(ctx, rctx)
5337	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5338	resTmp := ec.FieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
5339		ctx = rctx // use context from middleware stack in children
5340		return ec.resolvers.Mutation().NewBug(rctx, args["repoRef"].(*string), args["title"].(string), args["message"].(string), args["files"].([]git.Hash))
5341	})
5342	if resTmp == nil {
5343		if !ec.HasError(rctx) {
5344			ec.Errorf(ctx, "must not be null")
5345		}
5346		return graphql.Null
5347	}
5348	res := resTmp.(bug.Snapshot)
5349	rctx.Result = res
5350	ctx = ec.Tracer.StartFieldChildExecution(ctx)
5351
5352	return ec._Bug(ctx, field.Selections, &res)
5353}
5354
5355// nolint: vetshadow
5356func (ec *executionContext) _Mutation_addComment(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
5357	ctx = ec.Tracer.StartFieldExecution(ctx, field)
5358	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5359	rawArgs := field.ArgumentMap(ec.Variables)
5360	args, err := field_Mutation_addComment_args(rawArgs)
5361	if err != nil {
5362		ec.Error(ctx, err)
5363		return graphql.Null
5364	}
5365	rctx := &graphql.ResolverContext{
5366		Object: "Mutation",
5367		Args:   args,
5368		Field:  field,
5369	}
5370	ctx = graphql.WithResolverContext(ctx, rctx)
5371	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5372	resTmp := ec.FieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
5373		ctx = rctx // use context from middleware stack in children
5374		return ec.resolvers.Mutation().AddComment(rctx, args["repoRef"].(*string), args["prefix"].(string), args["message"].(string), args["files"].([]git.Hash))
5375	})
5376	if resTmp == nil {
5377		if !ec.HasError(rctx) {
5378			ec.Errorf(ctx, "must not be null")
5379		}
5380		return graphql.Null
5381	}
5382	res := resTmp.(bug.Snapshot)
5383	rctx.Result = res
5384	ctx = ec.Tracer.StartFieldChildExecution(ctx)
5385
5386	return ec._Bug(ctx, field.Selections, &res)
5387}
5388
5389// nolint: vetshadow
5390func (ec *executionContext) _Mutation_changeLabels(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
5391	ctx = ec.Tracer.StartFieldExecution(ctx, field)
5392	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5393	rawArgs := field.ArgumentMap(ec.Variables)
5394	args, err := field_Mutation_changeLabels_args(rawArgs)
5395	if err != nil {
5396		ec.Error(ctx, err)
5397		return graphql.Null
5398	}
5399	rctx := &graphql.ResolverContext{
5400		Object: "Mutation",
5401		Args:   args,
5402		Field:  field,
5403	}
5404	ctx = graphql.WithResolverContext(ctx, rctx)
5405	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5406	resTmp := ec.FieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
5407		ctx = rctx // use context from middleware stack in children
5408		return ec.resolvers.Mutation().ChangeLabels(rctx, args["repoRef"].(*string), args["prefix"].(string), args["added"].([]string), args["removed"].([]string))
5409	})
5410	if resTmp == nil {
5411		if !ec.HasError(rctx) {
5412			ec.Errorf(ctx, "must not be null")
5413		}
5414		return graphql.Null
5415	}
5416	res := resTmp.(bug.Snapshot)
5417	rctx.Result = res
5418	ctx = ec.Tracer.StartFieldChildExecution(ctx)
5419
5420	return ec._Bug(ctx, field.Selections, &res)
5421}
5422
5423// nolint: vetshadow
5424func (ec *executionContext) _Mutation_open(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
5425	ctx = ec.Tracer.StartFieldExecution(ctx, field)
5426	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5427	rawArgs := field.ArgumentMap(ec.Variables)
5428	args, err := field_Mutation_open_args(rawArgs)
5429	if err != nil {
5430		ec.Error(ctx, err)
5431		return graphql.Null
5432	}
5433	rctx := &graphql.ResolverContext{
5434		Object: "Mutation",
5435		Args:   args,
5436		Field:  field,
5437	}
5438	ctx = graphql.WithResolverContext(ctx, rctx)
5439	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5440	resTmp := ec.FieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
5441		ctx = rctx // use context from middleware stack in children
5442		return ec.resolvers.Mutation().Open(rctx, args["repoRef"].(*string), args["prefix"].(string))
5443	})
5444	if resTmp == nil {
5445		if !ec.HasError(rctx) {
5446			ec.Errorf(ctx, "must not be null")
5447		}
5448		return graphql.Null
5449	}
5450	res := resTmp.(bug.Snapshot)
5451	rctx.Result = res
5452	ctx = ec.Tracer.StartFieldChildExecution(ctx)
5453
5454	return ec._Bug(ctx, field.Selections, &res)
5455}
5456
5457// nolint: vetshadow
5458func (ec *executionContext) _Mutation_close(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
5459	ctx = ec.Tracer.StartFieldExecution(ctx, field)
5460	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5461	rawArgs := field.ArgumentMap(ec.Variables)
5462	args, err := field_Mutation_close_args(rawArgs)
5463	if err != nil {
5464		ec.Error(ctx, err)
5465		return graphql.Null
5466	}
5467	rctx := &graphql.ResolverContext{
5468		Object: "Mutation",
5469		Args:   args,
5470		Field:  field,
5471	}
5472	ctx = graphql.WithResolverContext(ctx, rctx)
5473	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5474	resTmp := ec.FieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
5475		ctx = rctx // use context from middleware stack in children
5476		return ec.resolvers.Mutation().Close(rctx, args["repoRef"].(*string), args["prefix"].(string))
5477	})
5478	if resTmp == nil {
5479		if !ec.HasError(rctx) {
5480			ec.Errorf(ctx, "must not be null")
5481		}
5482		return graphql.Null
5483	}
5484	res := resTmp.(bug.Snapshot)
5485	rctx.Result = res
5486	ctx = ec.Tracer.StartFieldChildExecution(ctx)
5487
5488	return ec._Bug(ctx, field.Selections, &res)
5489}
5490
5491// nolint: vetshadow
5492func (ec *executionContext) _Mutation_setTitle(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
5493	ctx = ec.Tracer.StartFieldExecution(ctx, field)
5494	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5495	rawArgs := field.ArgumentMap(ec.Variables)
5496	args, err := field_Mutation_setTitle_args(rawArgs)
5497	if err != nil {
5498		ec.Error(ctx, err)
5499		return graphql.Null
5500	}
5501	rctx := &graphql.ResolverContext{
5502		Object: "Mutation",
5503		Args:   args,
5504		Field:  field,
5505	}
5506	ctx = graphql.WithResolverContext(ctx, rctx)
5507	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5508	resTmp := ec.FieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
5509		ctx = rctx // use context from middleware stack in children
5510		return ec.resolvers.Mutation().SetTitle(rctx, args["repoRef"].(*string), args["prefix"].(string), args["title"].(string))
5511	})
5512	if resTmp == nil {
5513		if !ec.HasError(rctx) {
5514			ec.Errorf(ctx, "must not be null")
5515		}
5516		return graphql.Null
5517	}
5518	res := resTmp.(bug.Snapshot)
5519	rctx.Result = res
5520	ctx = ec.Tracer.StartFieldChildExecution(ctx)
5521
5522	return ec._Bug(ctx, field.Selections, &res)
5523}
5524
5525// nolint: vetshadow
5526func (ec *executionContext) _Mutation_commit(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
5527	ctx = ec.Tracer.StartFieldExecution(ctx, field)
5528	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5529	rawArgs := field.ArgumentMap(ec.Variables)
5530	args, err := field_Mutation_commit_args(rawArgs)
5531	if err != nil {
5532		ec.Error(ctx, err)
5533		return graphql.Null
5534	}
5535	rctx := &graphql.ResolverContext{
5536		Object: "Mutation",
5537		Args:   args,
5538		Field:  field,
5539	}
5540	ctx = graphql.WithResolverContext(ctx, rctx)
5541	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5542	resTmp := ec.FieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
5543		ctx = rctx // use context from middleware stack in children
5544		return ec.resolvers.Mutation().Commit(rctx, args["repoRef"].(*string), args["prefix"].(string))
5545	})
5546	if resTmp == nil {
5547		if !ec.HasError(rctx) {
5548			ec.Errorf(ctx, "must not be null")
5549		}
5550		return graphql.Null
5551	}
5552	res := resTmp.(bug.Snapshot)
5553	rctx.Result = res
5554	ctx = ec.Tracer.StartFieldChildExecution(ctx)
5555
5556	return ec._Bug(ctx, field.Selections, &res)
5557}
5558
5559var operationConnectionImplementors = []string{"OperationConnection"}
5560
5561// nolint: gocyclo, errcheck, gas, goconst
5562func (ec *executionContext) _OperationConnection(ctx context.Context, sel ast.SelectionSet, obj *models.OperationConnection) graphql.Marshaler {
5563	fields := graphql.CollectFields(ctx, sel, operationConnectionImplementors)
5564
5565	out := graphql.NewOrderedMap(len(fields))
5566	invalid := false
5567	for i, field := range fields {
5568		out.Keys[i] = field.Alias
5569
5570		switch field.Name {
5571		case "__typename":
5572			out.Values[i] = graphql.MarshalString("OperationConnection")
5573		case "edges":
5574			out.Values[i] = ec._OperationConnection_edges(ctx, field, obj)
5575			if out.Values[i] == graphql.Null {
5576				invalid = true
5577			}
5578		case "nodes":
5579			out.Values[i] = ec._OperationConnection_nodes(ctx, field, obj)
5580			if out.Values[i] == graphql.Null {
5581				invalid = true
5582			}
5583		case "pageInfo":
5584			out.Values[i] = ec._OperationConnection_pageInfo(ctx, field, obj)
5585			if out.Values[i] == graphql.Null {
5586				invalid = true
5587			}
5588		case "totalCount":
5589			out.Values[i] = ec._OperationConnection_totalCount(ctx, field, obj)
5590			if out.Values[i] == graphql.Null {
5591				invalid = true
5592			}
5593		default:
5594			panic("unknown field " + strconv.Quote(field.Name))
5595		}
5596	}
5597
5598	if invalid {
5599		return graphql.Null
5600	}
5601	return out
5602}
5603
5604// nolint: vetshadow
5605func (ec *executionContext) _OperationConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) graphql.Marshaler {
5606	ctx = ec.Tracer.StartFieldExecution(ctx, field)
5607	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5608	rctx := &graphql.ResolverContext{
5609		Object: "OperationConnection",
5610		Args:   nil,
5611		Field:  field,
5612	}
5613	ctx = graphql.WithResolverContext(ctx, rctx)
5614	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5615	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5616		ctx = rctx // use context from middleware stack in children
5617		return obj.Edges, nil
5618	})
5619	if resTmp == nil {
5620		if !ec.HasError(rctx) {
5621			ec.Errorf(ctx, "must not be null")
5622		}
5623		return graphql.Null
5624	}
5625	res := resTmp.([]models.OperationEdge)
5626	rctx.Result = res
5627	ctx = ec.Tracer.StartFieldChildExecution(ctx)
5628
5629	arr1 := make(graphql.Array, len(res))
5630	var wg sync.WaitGroup
5631
5632	isLen1 := len(res) == 1
5633	if !isLen1 {
5634		wg.Add(len(res))
5635	}
5636
5637	for idx1 := range res {
5638		idx1 := idx1
5639		rctx := &graphql.ResolverContext{
5640			Index:  &idx1,
5641			Result: &res[idx1],
5642		}
5643		ctx := graphql.WithResolverContext(ctx, rctx)
5644		f := func(idx1 int) {
5645			if !isLen1 {
5646				defer wg.Done()
5647			}
5648			arr1[idx1] = func() graphql.Marshaler {
5649
5650				return ec._OperationEdge(ctx, field.Selections, &res[idx1])
5651			}()
5652		}
5653		if isLen1 {
5654			f(idx1)
5655		} else {
5656			go f(idx1)
5657		}
5658
5659	}
5660	wg.Wait()
5661	return arr1
5662}
5663
5664// nolint: vetshadow
5665func (ec *executionContext) _OperationConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) graphql.Marshaler {
5666	ctx = ec.Tracer.StartFieldExecution(ctx, field)
5667	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5668	rctx := &graphql.ResolverContext{
5669		Object: "OperationConnection",
5670		Args:   nil,
5671		Field:  field,
5672	}
5673	ctx = graphql.WithResolverContext(ctx, rctx)
5674	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5675	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5676		ctx = rctx // use context from middleware stack in children
5677		return obj.Nodes, nil
5678	})
5679	if resTmp == nil {
5680		if !ec.HasError(rctx) {
5681			ec.Errorf(ctx, "must not be null")
5682		}
5683		return graphql.Null
5684	}
5685	res := resTmp.([]bug.Operation)
5686	rctx.Result = res
5687	ctx = ec.Tracer.StartFieldChildExecution(ctx)
5688
5689	arr1 := make(graphql.Array, len(res))
5690	var wg sync.WaitGroup
5691
5692	isLen1 := len(res) == 1
5693	if !isLen1 {
5694		wg.Add(len(res))
5695	}
5696
5697	for idx1 := range res {
5698		idx1 := idx1
5699		rctx := &graphql.ResolverContext{
5700			Index:  &idx1,
5701			Result: &res[idx1],
5702		}
5703		ctx := graphql.WithResolverContext(ctx, rctx)
5704		f := func(idx1 int) {
5705			if !isLen1 {
5706				defer wg.Done()
5707			}
5708			arr1[idx1] = func() graphql.Marshaler {
5709
5710				return ec._Operation(ctx, field.Selections, &res[idx1])
5711			}()
5712		}
5713		if isLen1 {
5714			f(idx1)
5715		} else {
5716			go f(idx1)
5717		}
5718
5719	}
5720	wg.Wait()
5721	return arr1
5722}
5723
5724// nolint: vetshadow
5725func (ec *executionContext) _OperationConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) graphql.Marshaler {
5726	ctx = ec.Tracer.StartFieldExecution(ctx, field)
5727	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5728	rctx := &graphql.ResolverContext{
5729		Object: "OperationConnection",
5730		Args:   nil,
5731		Field:  field,
5732	}
5733	ctx = graphql.WithResolverContext(ctx, rctx)
5734	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5735	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5736		ctx = rctx // use context from middleware stack in children
5737		return obj.PageInfo, nil
5738	})
5739	if resTmp == nil {
5740		if !ec.HasError(rctx) {
5741			ec.Errorf(ctx, "must not be null")
5742		}
5743		return graphql.Null
5744	}
5745	res := resTmp.(models.PageInfo)
5746	rctx.Result = res
5747	ctx = ec.Tracer.StartFieldChildExecution(ctx)
5748
5749	return ec._PageInfo(ctx, field.Selections, &res)
5750}
5751
5752// nolint: vetshadow
5753func (ec *executionContext) _OperationConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) graphql.Marshaler {
5754	ctx = ec.Tracer.StartFieldExecution(ctx, field)
5755	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5756	rctx := &graphql.ResolverContext{
5757		Object: "OperationConnection",
5758		Args:   nil,
5759		Field:  field,
5760	}
5761	ctx = graphql.WithResolverContext(ctx, rctx)
5762	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5763	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5764		ctx = rctx // use context from middleware stack in children
5765		return obj.TotalCount, nil
5766	})
5767	if resTmp == nil {
5768		if !ec.HasError(rctx) {
5769			ec.Errorf(ctx, "must not be null")
5770		}
5771		return graphql.Null
5772	}
5773	res := resTmp.(int)
5774	rctx.Result = res
5775	ctx = ec.Tracer.StartFieldChildExecution(ctx)
5776	return graphql.MarshalInt(res)
5777}
5778
5779var operationEdgeImplementors = []string{"OperationEdge"}
5780
5781// nolint: gocyclo, errcheck, gas, goconst
5782func (ec *executionContext) _OperationEdge(ctx context.Context, sel ast.SelectionSet, obj *models.OperationEdge) graphql.Marshaler {
5783	fields := graphql.CollectFields(ctx, sel, operationEdgeImplementors)
5784
5785	out := graphql.NewOrderedMap(len(fields))
5786	invalid := false
5787	for i, field := range fields {
5788		out.Keys[i] = field.Alias
5789
5790		switch field.Name {
5791		case "__typename":
5792			out.Values[i] = graphql.MarshalString("OperationEdge")
5793		case "cursor":
5794			out.Values[i] = ec._OperationEdge_cursor(ctx, field, obj)
5795			if out.Values[i] == graphql.Null {
5796				invalid = true
5797			}
5798		case "node":
5799			out.Values[i] = ec._OperationEdge_node(ctx, field, obj)
5800			if out.Values[i] == graphql.Null {
5801				invalid = true
5802			}
5803		default:
5804			panic("unknown field " + strconv.Quote(field.Name))
5805		}
5806	}
5807
5808	if invalid {
5809		return graphql.Null
5810	}
5811	return out
5812}
5813
5814// nolint: vetshadow
5815func (ec *executionContext) _OperationEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.OperationEdge) graphql.Marshaler {
5816	ctx = ec.Tracer.StartFieldExecution(ctx, field)
5817	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5818	rctx := &graphql.ResolverContext{
5819		Object: "OperationEdge",
5820		Args:   nil,
5821		Field:  field,
5822	}
5823	ctx = graphql.WithResolverContext(ctx, rctx)
5824	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5825	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5826		ctx = rctx // use context from middleware stack in children
5827		return obj.Cursor, nil
5828	})
5829	if resTmp == nil {
5830		if !ec.HasError(rctx) {
5831			ec.Errorf(ctx, "must not be null")
5832		}
5833		return graphql.Null
5834	}
5835	res := resTmp.(string)
5836	rctx.Result = res
5837	ctx = ec.Tracer.StartFieldChildExecution(ctx)
5838	return graphql.MarshalString(res)
5839}
5840
5841// nolint: vetshadow
5842func (ec *executionContext) _OperationEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.OperationEdge) graphql.Marshaler {
5843	ctx = ec.Tracer.StartFieldExecution(ctx, field)
5844	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5845	rctx := &graphql.ResolverContext{
5846		Object: "OperationEdge",
5847		Args:   nil,
5848		Field:  field,
5849	}
5850	ctx = graphql.WithResolverContext(ctx, rctx)
5851	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5852	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5853		ctx = rctx // use context from middleware stack in children
5854		return obj.Node, nil
5855	})
5856	if resTmp == nil {
5857		if !ec.HasError(rctx) {
5858			ec.Errorf(ctx, "must not be null")
5859		}
5860		return graphql.Null
5861	}
5862	res := resTmp.(bug.Operation)
5863	rctx.Result = res
5864	ctx = ec.Tracer.StartFieldChildExecution(ctx)
5865
5866	return ec._Operation(ctx, field.Selections, &res)
5867}
5868
5869var pageInfoImplementors = []string{"PageInfo"}
5870
5871// nolint: gocyclo, errcheck, gas, goconst
5872func (ec *executionContext) _PageInfo(ctx context.Context, sel ast.SelectionSet, obj *models.PageInfo) graphql.Marshaler {
5873	fields := graphql.CollectFields(ctx, sel, pageInfoImplementors)
5874
5875	out := graphql.NewOrderedMap(len(fields))
5876	invalid := false
5877	for i, field := range fields {
5878		out.Keys[i] = field.Alias
5879
5880		switch field.Name {
5881		case "__typename":
5882			out.Values[i] = graphql.MarshalString("PageInfo")
5883		case "hasNextPage":
5884			out.Values[i] = ec._PageInfo_hasNextPage(ctx, field, obj)
5885			if out.Values[i] == graphql.Null {
5886				invalid = true
5887			}
5888		case "hasPreviousPage":
5889			out.Values[i] = ec._PageInfo_hasPreviousPage(ctx, field, obj)
5890			if out.Values[i] == graphql.Null {
5891				invalid = true
5892			}
5893		case "startCursor":
5894			out.Values[i] = ec._PageInfo_startCursor(ctx, field, obj)
5895			if out.Values[i] == graphql.Null {
5896				invalid = true
5897			}
5898		case "endCursor":
5899			out.Values[i] = ec._PageInfo_endCursor(ctx, field, obj)
5900			if out.Values[i] == graphql.Null {
5901				invalid = true
5902			}
5903		default:
5904			panic("unknown field " + strconv.Quote(field.Name))
5905		}
5906	}
5907
5908	if invalid {
5909		return graphql.Null
5910	}
5911	return out
5912}
5913
5914// nolint: vetshadow
5915func (ec *executionContext) _PageInfo_hasNextPage(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) graphql.Marshaler {
5916	ctx = ec.Tracer.StartFieldExecution(ctx, field)
5917	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5918	rctx := &graphql.ResolverContext{
5919		Object: "PageInfo",
5920		Args:   nil,
5921		Field:  field,
5922	}
5923	ctx = graphql.WithResolverContext(ctx, rctx)
5924	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5925	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5926		ctx = rctx // use context from middleware stack in children
5927		return obj.HasNextPage, nil
5928	})
5929	if resTmp == nil {
5930		if !ec.HasError(rctx) {
5931			ec.Errorf(ctx, "must not be null")
5932		}
5933		return graphql.Null
5934	}
5935	res := resTmp.(bool)
5936	rctx.Result = res
5937	ctx = ec.Tracer.StartFieldChildExecution(ctx)
5938	return graphql.MarshalBoolean(res)
5939}
5940
5941// nolint: vetshadow
5942func (ec *executionContext) _PageInfo_hasPreviousPage(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) graphql.Marshaler {
5943	ctx = ec.Tracer.StartFieldExecution(ctx, field)
5944	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5945	rctx := &graphql.ResolverContext{
5946		Object: "PageInfo",
5947		Args:   nil,
5948		Field:  field,
5949	}
5950	ctx = graphql.WithResolverContext(ctx, rctx)
5951	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5952	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5953		ctx = rctx // use context from middleware stack in children
5954		return obj.HasPreviousPage, nil
5955	})
5956	if resTmp == nil {
5957		if !ec.HasError(rctx) {
5958			ec.Errorf(ctx, "must not be null")
5959		}
5960		return graphql.Null
5961	}
5962	res := resTmp.(bool)
5963	rctx.Result = res
5964	ctx = ec.Tracer.StartFieldChildExecution(ctx)
5965	return graphql.MarshalBoolean(res)
5966}
5967
5968// nolint: vetshadow
5969func (ec *executionContext) _PageInfo_startCursor(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) graphql.Marshaler {
5970	ctx = ec.Tracer.StartFieldExecution(ctx, field)
5971	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5972	rctx := &graphql.ResolverContext{
5973		Object: "PageInfo",
5974		Args:   nil,
5975		Field:  field,
5976	}
5977	ctx = graphql.WithResolverContext(ctx, rctx)
5978	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
5979	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
5980		ctx = rctx // use context from middleware stack in children
5981		return obj.StartCursor, nil
5982	})
5983	if resTmp == nil {
5984		if !ec.HasError(rctx) {
5985			ec.Errorf(ctx, "must not be null")
5986		}
5987		return graphql.Null
5988	}
5989	res := resTmp.(string)
5990	rctx.Result = res
5991	ctx = ec.Tracer.StartFieldChildExecution(ctx)
5992	return graphql.MarshalString(res)
5993}
5994
5995// nolint: vetshadow
5996func (ec *executionContext) _PageInfo_endCursor(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) graphql.Marshaler {
5997	ctx = ec.Tracer.StartFieldExecution(ctx, field)
5998	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
5999	rctx := &graphql.ResolverContext{
6000		Object: "PageInfo",
6001		Args:   nil,
6002		Field:  field,
6003	}
6004	ctx = graphql.WithResolverContext(ctx, rctx)
6005	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6006	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6007		ctx = rctx // use context from middleware stack in children
6008		return obj.EndCursor, nil
6009	})
6010	if resTmp == nil {
6011		if !ec.HasError(rctx) {
6012			ec.Errorf(ctx, "must not be null")
6013		}
6014		return graphql.Null
6015	}
6016	res := resTmp.(string)
6017	rctx.Result = res
6018	ctx = ec.Tracer.StartFieldChildExecution(ctx)
6019	return graphql.MarshalString(res)
6020}
6021
6022var queryImplementors = []string{"Query"}
6023
6024// nolint: gocyclo, errcheck, gas, goconst
6025func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
6026	fields := graphql.CollectFields(ctx, sel, queryImplementors)
6027
6028	ctx = graphql.WithResolverContext(ctx, &graphql.ResolverContext{
6029		Object: "Query",
6030	})
6031
6032	var wg sync.WaitGroup
6033	out := graphql.NewOrderedMap(len(fields))
6034	invalid := false
6035	for i, field := range fields {
6036		out.Keys[i] = field.Alias
6037
6038		switch field.Name {
6039		case "__typename":
6040			out.Values[i] = graphql.MarshalString("Query")
6041		case "defaultRepository":
6042			wg.Add(1)
6043			go func(i int, field graphql.CollectedField) {
6044				out.Values[i] = ec._Query_defaultRepository(ctx, field)
6045				wg.Done()
6046			}(i, field)
6047		case "repository":
6048			wg.Add(1)
6049			go func(i int, field graphql.CollectedField) {
6050				out.Values[i] = ec._Query_repository(ctx, field)
6051				wg.Done()
6052			}(i, field)
6053		case "__type":
6054			out.Values[i] = ec._Query___type(ctx, field)
6055		case "__schema":
6056			out.Values[i] = ec._Query___schema(ctx, field)
6057		default:
6058			panic("unknown field " + strconv.Quote(field.Name))
6059		}
6060	}
6061	wg.Wait()
6062	if invalid {
6063		return graphql.Null
6064	}
6065	return out
6066}
6067
6068// nolint: vetshadow
6069func (ec *executionContext) _Query_defaultRepository(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
6070	ctx = ec.Tracer.StartFieldExecution(ctx, field)
6071	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6072	rctx := &graphql.ResolverContext{
6073		Object: "Query",
6074		Args:   nil,
6075		Field:  field,
6076	}
6077	ctx = graphql.WithResolverContext(ctx, rctx)
6078	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6079	resTmp := ec.FieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
6080		ctx = rctx // use context from middleware stack in children
6081		return ec.resolvers.Query().DefaultRepository(rctx)
6082	})
6083	if resTmp == nil {
6084		return graphql.Null
6085	}
6086	res := resTmp.(*models.Repository)
6087	rctx.Result = res
6088	ctx = ec.Tracer.StartFieldChildExecution(ctx)
6089
6090	if res == nil {
6091		return graphql.Null
6092	}
6093
6094	return ec._Repository(ctx, field.Selections, res)
6095}
6096
6097// nolint: vetshadow
6098func (ec *executionContext) _Query_repository(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
6099	ctx = ec.Tracer.StartFieldExecution(ctx, field)
6100	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6101	rawArgs := field.ArgumentMap(ec.Variables)
6102	args, err := field_Query_repository_args(rawArgs)
6103	if err != nil {
6104		ec.Error(ctx, err)
6105		return graphql.Null
6106	}
6107	rctx := &graphql.ResolverContext{
6108		Object: "Query",
6109		Args:   args,
6110		Field:  field,
6111	}
6112	ctx = graphql.WithResolverContext(ctx, rctx)
6113	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6114	resTmp := ec.FieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
6115		ctx = rctx // use context from middleware stack in children
6116		return ec.resolvers.Query().Repository(rctx, args["id"].(string))
6117	})
6118	if resTmp == nil {
6119		return graphql.Null
6120	}
6121	res := resTmp.(*models.Repository)
6122	rctx.Result = res
6123	ctx = ec.Tracer.StartFieldChildExecution(ctx)
6124
6125	if res == nil {
6126		return graphql.Null
6127	}
6128
6129	return ec._Repository(ctx, field.Selections, res)
6130}
6131
6132// nolint: vetshadow
6133func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
6134	ctx = ec.Tracer.StartFieldExecution(ctx, field)
6135	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6136	rawArgs := field.ArgumentMap(ec.Variables)
6137	args, err := field_Query___type_args(rawArgs)
6138	if err != nil {
6139		ec.Error(ctx, err)
6140		return graphql.Null
6141	}
6142	rctx := &graphql.ResolverContext{
6143		Object: "Query",
6144		Args:   args,
6145		Field:  field,
6146	}
6147	ctx = graphql.WithResolverContext(ctx, rctx)
6148	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6149	resTmp := ec.FieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
6150		ctx = rctx // use context from middleware stack in children
6151		return ec.introspectType(args["name"].(string))
6152	})
6153	if resTmp == nil {
6154		return graphql.Null
6155	}
6156	res := resTmp.(*introspection.Type)
6157	rctx.Result = res
6158	ctx = ec.Tracer.StartFieldChildExecution(ctx)
6159
6160	if res == nil {
6161		return graphql.Null
6162	}
6163
6164	return ec.___Type(ctx, field.Selections, res)
6165}
6166
6167// nolint: vetshadow
6168func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
6169	ctx = ec.Tracer.StartFieldExecution(ctx, field)
6170	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6171	rctx := &graphql.ResolverContext{
6172		Object: "Query",
6173		Args:   nil,
6174		Field:  field,
6175	}
6176	ctx = graphql.WithResolverContext(ctx, rctx)
6177	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6178	resTmp := ec.FieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
6179		ctx = rctx // use context from middleware stack in children
6180		return ec.introspectSchema()
6181	})
6182	if resTmp == nil {
6183		return graphql.Null
6184	}
6185	res := resTmp.(*introspection.Schema)
6186	rctx.Result = res
6187	ctx = ec.Tracer.StartFieldChildExecution(ctx)
6188
6189	if res == nil {
6190		return graphql.Null
6191	}
6192
6193	return ec.___Schema(ctx, field.Selections, res)
6194}
6195
6196var repositoryImplementors = []string{"Repository"}
6197
6198// nolint: gocyclo, errcheck, gas, goconst
6199func (ec *executionContext) _Repository(ctx context.Context, sel ast.SelectionSet, obj *models.Repository) graphql.Marshaler {
6200	fields := graphql.CollectFields(ctx, sel, repositoryImplementors)
6201
6202	var wg sync.WaitGroup
6203	out := graphql.NewOrderedMap(len(fields))
6204	invalid := false
6205	for i, field := range fields {
6206		out.Keys[i] = field.Alias
6207
6208		switch field.Name {
6209		case "__typename":
6210			out.Values[i] = graphql.MarshalString("Repository")
6211		case "allBugs":
6212			wg.Add(1)
6213			go func(i int, field graphql.CollectedField) {
6214				out.Values[i] = ec._Repository_allBugs(ctx, field, obj)
6215				if out.Values[i] == graphql.Null {
6216					invalid = true
6217				}
6218				wg.Done()
6219			}(i, field)
6220		case "bug":
6221			wg.Add(1)
6222			go func(i int, field graphql.CollectedField) {
6223				out.Values[i] = ec._Repository_bug(ctx, field, obj)
6224				wg.Done()
6225			}(i, field)
6226		default:
6227			panic("unknown field " + strconv.Quote(field.Name))
6228		}
6229	}
6230	wg.Wait()
6231	if invalid {
6232		return graphql.Null
6233	}
6234	return out
6235}
6236
6237// nolint: vetshadow
6238func (ec *executionContext) _Repository_allBugs(ctx context.Context, field graphql.CollectedField, obj *models.Repository) graphql.Marshaler {
6239	ctx = ec.Tracer.StartFieldExecution(ctx, field)
6240	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6241	rawArgs := field.ArgumentMap(ec.Variables)
6242	args, err := field_Repository_allBugs_args(rawArgs)
6243	if err != nil {
6244		ec.Error(ctx, err)
6245		return graphql.Null
6246	}
6247	rctx := &graphql.ResolverContext{
6248		Object: "Repository",
6249		Args:   args,
6250		Field:  field,
6251	}
6252	ctx = graphql.WithResolverContext(ctx, rctx)
6253	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6254	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6255		ctx = rctx // use context from middleware stack in children
6256		return ec.resolvers.Repository().AllBugs(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int), args["query"].(*string))
6257	})
6258	if resTmp == nil {
6259		if !ec.HasError(rctx) {
6260			ec.Errorf(ctx, "must not be null")
6261		}
6262		return graphql.Null
6263	}
6264	res := resTmp.(models.BugConnection)
6265	rctx.Result = res
6266	ctx = ec.Tracer.StartFieldChildExecution(ctx)
6267
6268	return ec._BugConnection(ctx, field.Selections, &res)
6269}
6270
6271// nolint: vetshadow
6272func (ec *executionContext) _Repository_bug(ctx context.Context, field graphql.CollectedField, obj *models.Repository) graphql.Marshaler {
6273	ctx = ec.Tracer.StartFieldExecution(ctx, field)
6274	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6275	rawArgs := field.ArgumentMap(ec.Variables)
6276	args, err := field_Repository_bug_args(rawArgs)
6277	if err != nil {
6278		ec.Error(ctx, err)
6279		return graphql.Null
6280	}
6281	rctx := &graphql.ResolverContext{
6282		Object: "Repository",
6283		Args:   args,
6284		Field:  field,
6285	}
6286	ctx = graphql.WithResolverContext(ctx, rctx)
6287	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6288	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6289		ctx = rctx // use context from middleware stack in children
6290		return ec.resolvers.Repository().Bug(rctx, obj, args["prefix"].(string))
6291	})
6292	if resTmp == nil {
6293		return graphql.Null
6294	}
6295	res := resTmp.(*bug.Snapshot)
6296	rctx.Result = res
6297	ctx = ec.Tracer.StartFieldChildExecution(ctx)
6298
6299	if res == nil {
6300		return graphql.Null
6301	}
6302
6303	return ec._Bug(ctx, field.Selections, res)
6304}
6305
6306var setStatusOperationImplementors = []string{"SetStatusOperation", "Operation", "Authored"}
6307
6308// nolint: gocyclo, errcheck, gas, goconst
6309func (ec *executionContext) _SetStatusOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.SetStatusOperation) graphql.Marshaler {
6310	fields := graphql.CollectFields(ctx, sel, setStatusOperationImplementors)
6311
6312	var wg sync.WaitGroup
6313	out := graphql.NewOrderedMap(len(fields))
6314	invalid := false
6315	for i, field := range fields {
6316		out.Keys[i] = field.Alias
6317
6318		switch field.Name {
6319		case "__typename":
6320			out.Values[i] = graphql.MarshalString("SetStatusOperation")
6321		case "hash":
6322			out.Values[i] = ec._SetStatusOperation_hash(ctx, field, obj)
6323			if out.Values[i] == graphql.Null {
6324				invalid = true
6325			}
6326		case "author":
6327			out.Values[i] = ec._SetStatusOperation_author(ctx, field, obj)
6328			if out.Values[i] == graphql.Null {
6329				invalid = true
6330			}
6331		case "date":
6332			wg.Add(1)
6333			go func(i int, field graphql.CollectedField) {
6334				out.Values[i] = ec._SetStatusOperation_date(ctx, field, obj)
6335				if out.Values[i] == graphql.Null {
6336					invalid = true
6337				}
6338				wg.Done()
6339			}(i, field)
6340		case "status":
6341			wg.Add(1)
6342			go func(i int, field graphql.CollectedField) {
6343				out.Values[i] = ec._SetStatusOperation_status(ctx, field, obj)
6344				if out.Values[i] == graphql.Null {
6345					invalid = true
6346				}
6347				wg.Done()
6348			}(i, field)
6349		default:
6350			panic("unknown field " + strconv.Quote(field.Name))
6351		}
6352	}
6353	wg.Wait()
6354	if invalid {
6355		return graphql.Null
6356	}
6357	return out
6358}
6359
6360// nolint: vetshadow
6361func (ec *executionContext) _SetStatusOperation_hash(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) graphql.Marshaler {
6362	ctx = ec.Tracer.StartFieldExecution(ctx, field)
6363	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6364	rctx := &graphql.ResolverContext{
6365		Object: "SetStatusOperation",
6366		Args:   nil,
6367		Field:  field,
6368	}
6369	ctx = graphql.WithResolverContext(ctx, rctx)
6370	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6371	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6372		ctx = rctx // use context from middleware stack in children
6373		return obj.Hash()
6374	})
6375	if resTmp == nil {
6376		if !ec.HasError(rctx) {
6377			ec.Errorf(ctx, "must not be null")
6378		}
6379		return graphql.Null
6380	}
6381	res := resTmp.(git.Hash)
6382	rctx.Result = res
6383	ctx = ec.Tracer.StartFieldChildExecution(ctx)
6384	return res
6385}
6386
6387// nolint: vetshadow
6388func (ec *executionContext) _SetStatusOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) graphql.Marshaler {
6389	ctx = ec.Tracer.StartFieldExecution(ctx, field)
6390	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6391	rctx := &graphql.ResolverContext{
6392		Object: "SetStatusOperation",
6393		Args:   nil,
6394		Field:  field,
6395	}
6396	ctx = graphql.WithResolverContext(ctx, rctx)
6397	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6398	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6399		ctx = rctx // use context from middleware stack in children
6400		return obj.Author, nil
6401	})
6402	if resTmp == nil {
6403		if !ec.HasError(rctx) {
6404			ec.Errorf(ctx, "must not be null")
6405		}
6406		return graphql.Null
6407	}
6408	res := resTmp.(identity.Interface)
6409	rctx.Result = res
6410	ctx = ec.Tracer.StartFieldChildExecution(ctx)
6411
6412	return ec._Identity(ctx, field.Selections, &res)
6413}
6414
6415// nolint: vetshadow
6416func (ec *executionContext) _SetStatusOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) graphql.Marshaler {
6417	ctx = ec.Tracer.StartFieldExecution(ctx, field)
6418	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6419	rctx := &graphql.ResolverContext{
6420		Object: "SetStatusOperation",
6421		Args:   nil,
6422		Field:  field,
6423	}
6424	ctx = graphql.WithResolverContext(ctx, rctx)
6425	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6426	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6427		ctx = rctx // use context from middleware stack in children
6428		return ec.resolvers.SetStatusOperation().Date(rctx, obj)
6429	})
6430	if resTmp == nil {
6431		if !ec.HasError(rctx) {
6432			ec.Errorf(ctx, "must not be null")
6433		}
6434		return graphql.Null
6435	}
6436	res := resTmp.(time.Time)
6437	rctx.Result = res
6438	ctx = ec.Tracer.StartFieldChildExecution(ctx)
6439	return graphql.MarshalTime(res)
6440}
6441
6442// nolint: vetshadow
6443func (ec *executionContext) _SetStatusOperation_status(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) graphql.Marshaler {
6444	ctx = ec.Tracer.StartFieldExecution(ctx, field)
6445	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6446	rctx := &graphql.ResolverContext{
6447		Object: "SetStatusOperation",
6448		Args:   nil,
6449		Field:  field,
6450	}
6451	ctx = graphql.WithResolverContext(ctx, rctx)
6452	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6453	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6454		ctx = rctx // use context from middleware stack in children
6455		return ec.resolvers.SetStatusOperation().Status(rctx, obj)
6456	})
6457	if resTmp == nil {
6458		if !ec.HasError(rctx) {
6459			ec.Errorf(ctx, "must not be null")
6460		}
6461		return graphql.Null
6462	}
6463	res := resTmp.(models.Status)
6464	rctx.Result = res
6465	ctx = ec.Tracer.StartFieldChildExecution(ctx)
6466	return res
6467}
6468
6469var setStatusTimelineItemImplementors = []string{"SetStatusTimelineItem", "TimelineItem"}
6470
6471// nolint: gocyclo, errcheck, gas, goconst
6472func (ec *executionContext) _SetStatusTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.SetStatusTimelineItem) graphql.Marshaler {
6473	fields := graphql.CollectFields(ctx, sel, setStatusTimelineItemImplementors)
6474
6475	var wg sync.WaitGroup
6476	out := graphql.NewOrderedMap(len(fields))
6477	invalid := false
6478	for i, field := range fields {
6479		out.Keys[i] = field.Alias
6480
6481		switch field.Name {
6482		case "__typename":
6483			out.Values[i] = graphql.MarshalString("SetStatusTimelineItem")
6484		case "hash":
6485			out.Values[i] = ec._SetStatusTimelineItem_hash(ctx, field, obj)
6486			if out.Values[i] == graphql.Null {
6487				invalid = true
6488			}
6489		case "author":
6490			out.Values[i] = ec._SetStatusTimelineItem_author(ctx, field, obj)
6491			if out.Values[i] == graphql.Null {
6492				invalid = true
6493			}
6494		case "date":
6495			wg.Add(1)
6496			go func(i int, field graphql.CollectedField) {
6497				out.Values[i] = ec._SetStatusTimelineItem_date(ctx, field, obj)
6498				if out.Values[i] == graphql.Null {
6499					invalid = true
6500				}
6501				wg.Done()
6502			}(i, field)
6503		case "status":
6504			wg.Add(1)
6505			go func(i int, field graphql.CollectedField) {
6506				out.Values[i] = ec._SetStatusTimelineItem_status(ctx, field, obj)
6507				if out.Values[i] == graphql.Null {
6508					invalid = true
6509				}
6510				wg.Done()
6511			}(i, field)
6512		default:
6513			panic("unknown field " + strconv.Quote(field.Name))
6514		}
6515	}
6516	wg.Wait()
6517	if invalid {
6518		return graphql.Null
6519	}
6520	return out
6521}
6522
6523// nolint: vetshadow
6524func (ec *executionContext) _SetStatusTimelineItem_hash(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) graphql.Marshaler {
6525	ctx = ec.Tracer.StartFieldExecution(ctx, field)
6526	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6527	rctx := &graphql.ResolverContext{
6528		Object: "SetStatusTimelineItem",
6529		Args:   nil,
6530		Field:  field,
6531	}
6532	ctx = graphql.WithResolverContext(ctx, rctx)
6533	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6534	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6535		ctx = rctx // use context from middleware stack in children
6536		return obj.Hash(), nil
6537	})
6538	if resTmp == nil {
6539		if !ec.HasError(rctx) {
6540			ec.Errorf(ctx, "must not be null")
6541		}
6542		return graphql.Null
6543	}
6544	res := resTmp.(git.Hash)
6545	rctx.Result = res
6546	ctx = ec.Tracer.StartFieldChildExecution(ctx)
6547	return res
6548}
6549
6550// nolint: vetshadow
6551func (ec *executionContext) _SetStatusTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) graphql.Marshaler {
6552	ctx = ec.Tracer.StartFieldExecution(ctx, field)
6553	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6554	rctx := &graphql.ResolverContext{
6555		Object: "SetStatusTimelineItem",
6556		Args:   nil,
6557		Field:  field,
6558	}
6559	ctx = graphql.WithResolverContext(ctx, rctx)
6560	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6561	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6562		ctx = rctx // use context from middleware stack in children
6563		return obj.Author, nil
6564	})
6565	if resTmp == nil {
6566		if !ec.HasError(rctx) {
6567			ec.Errorf(ctx, "must not be null")
6568		}
6569		return graphql.Null
6570	}
6571	res := resTmp.(identity.Interface)
6572	rctx.Result = res
6573	ctx = ec.Tracer.StartFieldChildExecution(ctx)
6574
6575	return ec._Identity(ctx, field.Selections, &res)
6576}
6577
6578// nolint: vetshadow
6579func (ec *executionContext) _SetStatusTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) graphql.Marshaler {
6580	ctx = ec.Tracer.StartFieldExecution(ctx, field)
6581	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6582	rctx := &graphql.ResolverContext{
6583		Object: "SetStatusTimelineItem",
6584		Args:   nil,
6585		Field:  field,
6586	}
6587	ctx = graphql.WithResolverContext(ctx, rctx)
6588	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6589	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6590		ctx = rctx // use context from middleware stack in children
6591		return ec.resolvers.SetStatusTimelineItem().Date(rctx, obj)
6592	})
6593	if resTmp == nil {
6594		if !ec.HasError(rctx) {
6595			ec.Errorf(ctx, "must not be null")
6596		}
6597		return graphql.Null
6598	}
6599	res := resTmp.(time.Time)
6600	rctx.Result = res
6601	ctx = ec.Tracer.StartFieldChildExecution(ctx)
6602	return graphql.MarshalTime(res)
6603}
6604
6605// nolint: vetshadow
6606func (ec *executionContext) _SetStatusTimelineItem_status(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) graphql.Marshaler {
6607	ctx = ec.Tracer.StartFieldExecution(ctx, field)
6608	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6609	rctx := &graphql.ResolverContext{
6610		Object: "SetStatusTimelineItem",
6611		Args:   nil,
6612		Field:  field,
6613	}
6614	ctx = graphql.WithResolverContext(ctx, rctx)
6615	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6616	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6617		ctx = rctx // use context from middleware stack in children
6618		return ec.resolvers.SetStatusTimelineItem().Status(rctx, obj)
6619	})
6620	if resTmp == nil {
6621		if !ec.HasError(rctx) {
6622			ec.Errorf(ctx, "must not be null")
6623		}
6624		return graphql.Null
6625	}
6626	res := resTmp.(models.Status)
6627	rctx.Result = res
6628	ctx = ec.Tracer.StartFieldChildExecution(ctx)
6629	return res
6630}
6631
6632var setTitleOperationImplementors = []string{"SetTitleOperation", "Operation", "Authored"}
6633
6634// nolint: gocyclo, errcheck, gas, goconst
6635func (ec *executionContext) _SetTitleOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.SetTitleOperation) graphql.Marshaler {
6636	fields := graphql.CollectFields(ctx, sel, setTitleOperationImplementors)
6637
6638	var wg sync.WaitGroup
6639	out := graphql.NewOrderedMap(len(fields))
6640	invalid := false
6641	for i, field := range fields {
6642		out.Keys[i] = field.Alias
6643
6644		switch field.Name {
6645		case "__typename":
6646			out.Values[i] = graphql.MarshalString("SetTitleOperation")
6647		case "hash":
6648			out.Values[i] = ec._SetTitleOperation_hash(ctx, field, obj)
6649			if out.Values[i] == graphql.Null {
6650				invalid = true
6651			}
6652		case "author":
6653			out.Values[i] = ec._SetTitleOperation_author(ctx, field, obj)
6654			if out.Values[i] == graphql.Null {
6655				invalid = true
6656			}
6657		case "date":
6658			wg.Add(1)
6659			go func(i int, field graphql.CollectedField) {
6660				out.Values[i] = ec._SetTitleOperation_date(ctx, field, obj)
6661				if out.Values[i] == graphql.Null {
6662					invalid = true
6663				}
6664				wg.Done()
6665			}(i, field)
6666		case "title":
6667			out.Values[i] = ec._SetTitleOperation_title(ctx, field, obj)
6668			if out.Values[i] == graphql.Null {
6669				invalid = true
6670			}
6671		case "was":
6672			out.Values[i] = ec._SetTitleOperation_was(ctx, field, obj)
6673			if out.Values[i] == graphql.Null {
6674				invalid = true
6675			}
6676		default:
6677			panic("unknown field " + strconv.Quote(field.Name))
6678		}
6679	}
6680	wg.Wait()
6681	if invalid {
6682		return graphql.Null
6683	}
6684	return out
6685}
6686
6687// nolint: vetshadow
6688func (ec *executionContext) _SetTitleOperation_hash(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) graphql.Marshaler {
6689	ctx = ec.Tracer.StartFieldExecution(ctx, field)
6690	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6691	rctx := &graphql.ResolverContext{
6692		Object: "SetTitleOperation",
6693		Args:   nil,
6694		Field:  field,
6695	}
6696	ctx = graphql.WithResolverContext(ctx, rctx)
6697	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6698	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6699		ctx = rctx // use context from middleware stack in children
6700		return obj.Hash()
6701	})
6702	if resTmp == nil {
6703		if !ec.HasError(rctx) {
6704			ec.Errorf(ctx, "must not be null")
6705		}
6706		return graphql.Null
6707	}
6708	res := resTmp.(git.Hash)
6709	rctx.Result = res
6710	ctx = ec.Tracer.StartFieldChildExecution(ctx)
6711	return res
6712}
6713
6714// nolint: vetshadow
6715func (ec *executionContext) _SetTitleOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) graphql.Marshaler {
6716	ctx = ec.Tracer.StartFieldExecution(ctx, field)
6717	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6718	rctx := &graphql.ResolverContext{
6719		Object: "SetTitleOperation",
6720		Args:   nil,
6721		Field:  field,
6722	}
6723	ctx = graphql.WithResolverContext(ctx, rctx)
6724	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6725	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6726		ctx = rctx // use context from middleware stack in children
6727		return obj.Author, nil
6728	})
6729	if resTmp == nil {
6730		if !ec.HasError(rctx) {
6731			ec.Errorf(ctx, "must not be null")
6732		}
6733		return graphql.Null
6734	}
6735	res := resTmp.(identity.Interface)
6736	rctx.Result = res
6737	ctx = ec.Tracer.StartFieldChildExecution(ctx)
6738
6739	return ec._Identity(ctx, field.Selections, &res)
6740}
6741
6742// nolint: vetshadow
6743func (ec *executionContext) _SetTitleOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) graphql.Marshaler {
6744	ctx = ec.Tracer.StartFieldExecution(ctx, field)
6745	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6746	rctx := &graphql.ResolverContext{
6747		Object: "SetTitleOperation",
6748		Args:   nil,
6749		Field:  field,
6750	}
6751	ctx = graphql.WithResolverContext(ctx, rctx)
6752	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6753	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6754		ctx = rctx // use context from middleware stack in children
6755		return ec.resolvers.SetTitleOperation().Date(rctx, obj)
6756	})
6757	if resTmp == nil {
6758		if !ec.HasError(rctx) {
6759			ec.Errorf(ctx, "must not be null")
6760		}
6761		return graphql.Null
6762	}
6763	res := resTmp.(time.Time)
6764	rctx.Result = res
6765	ctx = ec.Tracer.StartFieldChildExecution(ctx)
6766	return graphql.MarshalTime(res)
6767}
6768
6769// nolint: vetshadow
6770func (ec *executionContext) _SetTitleOperation_title(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) graphql.Marshaler {
6771	ctx = ec.Tracer.StartFieldExecution(ctx, field)
6772	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6773	rctx := &graphql.ResolverContext{
6774		Object: "SetTitleOperation",
6775		Args:   nil,
6776		Field:  field,
6777	}
6778	ctx = graphql.WithResolverContext(ctx, rctx)
6779	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6780	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6781		ctx = rctx // use context from middleware stack in children
6782		return obj.Title, nil
6783	})
6784	if resTmp == nil {
6785		if !ec.HasError(rctx) {
6786			ec.Errorf(ctx, "must not be null")
6787		}
6788		return graphql.Null
6789	}
6790	res := resTmp.(string)
6791	rctx.Result = res
6792	ctx = ec.Tracer.StartFieldChildExecution(ctx)
6793	return graphql.MarshalString(res)
6794}
6795
6796// nolint: vetshadow
6797func (ec *executionContext) _SetTitleOperation_was(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) graphql.Marshaler {
6798	ctx = ec.Tracer.StartFieldExecution(ctx, field)
6799	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6800	rctx := &graphql.ResolverContext{
6801		Object: "SetTitleOperation",
6802		Args:   nil,
6803		Field:  field,
6804	}
6805	ctx = graphql.WithResolverContext(ctx, rctx)
6806	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6807	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6808		ctx = rctx // use context from middleware stack in children
6809		return obj.Was, nil
6810	})
6811	if resTmp == nil {
6812		if !ec.HasError(rctx) {
6813			ec.Errorf(ctx, "must not be null")
6814		}
6815		return graphql.Null
6816	}
6817	res := resTmp.(string)
6818	rctx.Result = res
6819	ctx = ec.Tracer.StartFieldChildExecution(ctx)
6820	return graphql.MarshalString(res)
6821}
6822
6823var setTitleTimelineItemImplementors = []string{"SetTitleTimelineItem", "TimelineItem"}
6824
6825// nolint: gocyclo, errcheck, gas, goconst
6826func (ec *executionContext) _SetTitleTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.SetTitleTimelineItem) graphql.Marshaler {
6827	fields := graphql.CollectFields(ctx, sel, setTitleTimelineItemImplementors)
6828
6829	var wg sync.WaitGroup
6830	out := graphql.NewOrderedMap(len(fields))
6831	invalid := false
6832	for i, field := range fields {
6833		out.Keys[i] = field.Alias
6834
6835		switch field.Name {
6836		case "__typename":
6837			out.Values[i] = graphql.MarshalString("SetTitleTimelineItem")
6838		case "hash":
6839			out.Values[i] = ec._SetTitleTimelineItem_hash(ctx, field, obj)
6840			if out.Values[i] == graphql.Null {
6841				invalid = true
6842			}
6843		case "author":
6844			out.Values[i] = ec._SetTitleTimelineItem_author(ctx, field, obj)
6845			if out.Values[i] == graphql.Null {
6846				invalid = true
6847			}
6848		case "date":
6849			wg.Add(1)
6850			go func(i int, field graphql.CollectedField) {
6851				out.Values[i] = ec._SetTitleTimelineItem_date(ctx, field, obj)
6852				if out.Values[i] == graphql.Null {
6853					invalid = true
6854				}
6855				wg.Done()
6856			}(i, field)
6857		case "title":
6858			out.Values[i] = ec._SetTitleTimelineItem_title(ctx, field, obj)
6859			if out.Values[i] == graphql.Null {
6860				invalid = true
6861			}
6862		case "was":
6863			out.Values[i] = ec._SetTitleTimelineItem_was(ctx, field, obj)
6864			if out.Values[i] == graphql.Null {
6865				invalid = true
6866			}
6867		default:
6868			panic("unknown field " + strconv.Quote(field.Name))
6869		}
6870	}
6871	wg.Wait()
6872	if invalid {
6873		return graphql.Null
6874	}
6875	return out
6876}
6877
6878// nolint: vetshadow
6879func (ec *executionContext) _SetTitleTimelineItem_hash(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) graphql.Marshaler {
6880	ctx = ec.Tracer.StartFieldExecution(ctx, field)
6881	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6882	rctx := &graphql.ResolverContext{
6883		Object: "SetTitleTimelineItem",
6884		Args:   nil,
6885		Field:  field,
6886	}
6887	ctx = graphql.WithResolverContext(ctx, rctx)
6888	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6889	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6890		ctx = rctx // use context from middleware stack in children
6891		return obj.Hash(), nil
6892	})
6893	if resTmp == nil {
6894		if !ec.HasError(rctx) {
6895			ec.Errorf(ctx, "must not be null")
6896		}
6897		return graphql.Null
6898	}
6899	res := resTmp.(git.Hash)
6900	rctx.Result = res
6901	ctx = ec.Tracer.StartFieldChildExecution(ctx)
6902	return res
6903}
6904
6905// nolint: vetshadow
6906func (ec *executionContext) _SetTitleTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) graphql.Marshaler {
6907	ctx = ec.Tracer.StartFieldExecution(ctx, field)
6908	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6909	rctx := &graphql.ResolverContext{
6910		Object: "SetTitleTimelineItem",
6911		Args:   nil,
6912		Field:  field,
6913	}
6914	ctx = graphql.WithResolverContext(ctx, rctx)
6915	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6916	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6917		ctx = rctx // use context from middleware stack in children
6918		return obj.Author, nil
6919	})
6920	if resTmp == nil {
6921		if !ec.HasError(rctx) {
6922			ec.Errorf(ctx, "must not be null")
6923		}
6924		return graphql.Null
6925	}
6926	res := resTmp.(identity.Interface)
6927	rctx.Result = res
6928	ctx = ec.Tracer.StartFieldChildExecution(ctx)
6929
6930	return ec._Identity(ctx, field.Selections, &res)
6931}
6932
6933// nolint: vetshadow
6934func (ec *executionContext) _SetTitleTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) graphql.Marshaler {
6935	ctx = ec.Tracer.StartFieldExecution(ctx, field)
6936	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6937	rctx := &graphql.ResolverContext{
6938		Object: "SetTitleTimelineItem",
6939		Args:   nil,
6940		Field:  field,
6941	}
6942	ctx = graphql.WithResolverContext(ctx, rctx)
6943	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6944	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6945		ctx = rctx // use context from middleware stack in children
6946		return ec.resolvers.SetTitleTimelineItem().Date(rctx, obj)
6947	})
6948	if resTmp == nil {
6949		if !ec.HasError(rctx) {
6950			ec.Errorf(ctx, "must not be null")
6951		}
6952		return graphql.Null
6953	}
6954	res := resTmp.(time.Time)
6955	rctx.Result = res
6956	ctx = ec.Tracer.StartFieldChildExecution(ctx)
6957	return graphql.MarshalTime(res)
6958}
6959
6960// nolint: vetshadow
6961func (ec *executionContext) _SetTitleTimelineItem_title(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) graphql.Marshaler {
6962	ctx = ec.Tracer.StartFieldExecution(ctx, field)
6963	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6964	rctx := &graphql.ResolverContext{
6965		Object: "SetTitleTimelineItem",
6966		Args:   nil,
6967		Field:  field,
6968	}
6969	ctx = graphql.WithResolverContext(ctx, rctx)
6970	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6971	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6972		ctx = rctx // use context from middleware stack in children
6973		return obj.Title, nil
6974	})
6975	if resTmp == nil {
6976		if !ec.HasError(rctx) {
6977			ec.Errorf(ctx, "must not be null")
6978		}
6979		return graphql.Null
6980	}
6981	res := resTmp.(string)
6982	rctx.Result = res
6983	ctx = ec.Tracer.StartFieldChildExecution(ctx)
6984	return graphql.MarshalString(res)
6985}
6986
6987// nolint: vetshadow
6988func (ec *executionContext) _SetTitleTimelineItem_was(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) graphql.Marshaler {
6989	ctx = ec.Tracer.StartFieldExecution(ctx, field)
6990	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
6991	rctx := &graphql.ResolverContext{
6992		Object: "SetTitleTimelineItem",
6993		Args:   nil,
6994		Field:  field,
6995	}
6996	ctx = graphql.WithResolverContext(ctx, rctx)
6997	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
6998	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
6999		ctx = rctx // use context from middleware stack in children
7000		return obj.Was, nil
7001	})
7002	if resTmp == nil {
7003		if !ec.HasError(rctx) {
7004			ec.Errorf(ctx, "must not be null")
7005		}
7006		return graphql.Null
7007	}
7008	res := resTmp.(string)
7009	rctx.Result = res
7010	ctx = ec.Tracer.StartFieldChildExecution(ctx)
7011	return graphql.MarshalString(res)
7012}
7013
7014var timelineItemConnectionImplementors = []string{"TimelineItemConnection"}
7015
7016// nolint: gocyclo, errcheck, gas, goconst
7017func (ec *executionContext) _TimelineItemConnection(ctx context.Context, sel ast.SelectionSet, obj *models.TimelineItemConnection) graphql.Marshaler {
7018	fields := graphql.CollectFields(ctx, sel, timelineItemConnectionImplementors)
7019
7020	out := graphql.NewOrderedMap(len(fields))
7021	invalid := false
7022	for i, field := range fields {
7023		out.Keys[i] = field.Alias
7024
7025		switch field.Name {
7026		case "__typename":
7027			out.Values[i] = graphql.MarshalString("TimelineItemConnection")
7028		case "edges":
7029			out.Values[i] = ec._TimelineItemConnection_edges(ctx, field, obj)
7030			if out.Values[i] == graphql.Null {
7031				invalid = true
7032			}
7033		case "nodes":
7034			out.Values[i] = ec._TimelineItemConnection_nodes(ctx, field, obj)
7035			if out.Values[i] == graphql.Null {
7036				invalid = true
7037			}
7038		case "pageInfo":
7039			out.Values[i] = ec._TimelineItemConnection_pageInfo(ctx, field, obj)
7040			if out.Values[i] == graphql.Null {
7041				invalid = true
7042			}
7043		case "totalCount":
7044			out.Values[i] = ec._TimelineItemConnection_totalCount(ctx, field, obj)
7045			if out.Values[i] == graphql.Null {
7046				invalid = true
7047			}
7048		default:
7049			panic("unknown field " + strconv.Quote(field.Name))
7050		}
7051	}
7052
7053	if invalid {
7054		return graphql.Null
7055	}
7056	return out
7057}
7058
7059// nolint: vetshadow
7060func (ec *executionContext) _TimelineItemConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) graphql.Marshaler {
7061	ctx = ec.Tracer.StartFieldExecution(ctx, field)
7062	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7063	rctx := &graphql.ResolverContext{
7064		Object: "TimelineItemConnection",
7065		Args:   nil,
7066		Field:  field,
7067	}
7068	ctx = graphql.WithResolverContext(ctx, rctx)
7069	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7070	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7071		ctx = rctx // use context from middleware stack in children
7072		return obj.Edges, nil
7073	})
7074	if resTmp == nil {
7075		if !ec.HasError(rctx) {
7076			ec.Errorf(ctx, "must not be null")
7077		}
7078		return graphql.Null
7079	}
7080	res := resTmp.([]models.TimelineItemEdge)
7081	rctx.Result = res
7082	ctx = ec.Tracer.StartFieldChildExecution(ctx)
7083
7084	arr1 := make(graphql.Array, len(res))
7085	var wg sync.WaitGroup
7086
7087	isLen1 := len(res) == 1
7088	if !isLen1 {
7089		wg.Add(len(res))
7090	}
7091
7092	for idx1 := range res {
7093		idx1 := idx1
7094		rctx := &graphql.ResolverContext{
7095			Index:  &idx1,
7096			Result: &res[idx1],
7097		}
7098		ctx := graphql.WithResolverContext(ctx, rctx)
7099		f := func(idx1 int) {
7100			if !isLen1 {
7101				defer wg.Done()
7102			}
7103			arr1[idx1] = func() graphql.Marshaler {
7104
7105				return ec._TimelineItemEdge(ctx, field.Selections, &res[idx1])
7106			}()
7107		}
7108		if isLen1 {
7109			f(idx1)
7110		} else {
7111			go f(idx1)
7112		}
7113
7114	}
7115	wg.Wait()
7116	return arr1
7117}
7118
7119// nolint: vetshadow
7120func (ec *executionContext) _TimelineItemConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) graphql.Marshaler {
7121	ctx = ec.Tracer.StartFieldExecution(ctx, field)
7122	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7123	rctx := &graphql.ResolverContext{
7124		Object: "TimelineItemConnection",
7125		Args:   nil,
7126		Field:  field,
7127	}
7128	ctx = graphql.WithResolverContext(ctx, rctx)
7129	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7130	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7131		ctx = rctx // use context from middleware stack in children
7132		return obj.Nodes, nil
7133	})
7134	if resTmp == nil {
7135		if !ec.HasError(rctx) {
7136			ec.Errorf(ctx, "must not be null")
7137		}
7138		return graphql.Null
7139	}
7140	res := resTmp.([]bug.TimelineItem)
7141	rctx.Result = res
7142	ctx = ec.Tracer.StartFieldChildExecution(ctx)
7143
7144	arr1 := make(graphql.Array, len(res))
7145	var wg sync.WaitGroup
7146
7147	isLen1 := len(res) == 1
7148	if !isLen1 {
7149		wg.Add(len(res))
7150	}
7151
7152	for idx1 := range res {
7153		idx1 := idx1
7154		rctx := &graphql.ResolverContext{
7155			Index:  &idx1,
7156			Result: &res[idx1],
7157		}
7158		ctx := graphql.WithResolverContext(ctx, rctx)
7159		f := func(idx1 int) {
7160			if !isLen1 {
7161				defer wg.Done()
7162			}
7163			arr1[idx1] = func() graphql.Marshaler {
7164
7165				return ec._TimelineItem(ctx, field.Selections, &res[idx1])
7166			}()
7167		}
7168		if isLen1 {
7169			f(idx1)
7170		} else {
7171			go f(idx1)
7172		}
7173
7174	}
7175	wg.Wait()
7176	return arr1
7177}
7178
7179// nolint: vetshadow
7180func (ec *executionContext) _TimelineItemConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) graphql.Marshaler {
7181	ctx = ec.Tracer.StartFieldExecution(ctx, field)
7182	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7183	rctx := &graphql.ResolverContext{
7184		Object: "TimelineItemConnection",
7185		Args:   nil,
7186		Field:  field,
7187	}
7188	ctx = graphql.WithResolverContext(ctx, rctx)
7189	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7190	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7191		ctx = rctx // use context from middleware stack in children
7192		return obj.PageInfo, nil
7193	})
7194	if resTmp == nil {
7195		if !ec.HasError(rctx) {
7196			ec.Errorf(ctx, "must not be null")
7197		}
7198		return graphql.Null
7199	}
7200	res := resTmp.(models.PageInfo)
7201	rctx.Result = res
7202	ctx = ec.Tracer.StartFieldChildExecution(ctx)
7203
7204	return ec._PageInfo(ctx, field.Selections, &res)
7205}
7206
7207// nolint: vetshadow
7208func (ec *executionContext) _TimelineItemConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) graphql.Marshaler {
7209	ctx = ec.Tracer.StartFieldExecution(ctx, field)
7210	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7211	rctx := &graphql.ResolverContext{
7212		Object: "TimelineItemConnection",
7213		Args:   nil,
7214		Field:  field,
7215	}
7216	ctx = graphql.WithResolverContext(ctx, rctx)
7217	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7218	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7219		ctx = rctx // use context from middleware stack in children
7220		return obj.TotalCount, nil
7221	})
7222	if resTmp == nil {
7223		if !ec.HasError(rctx) {
7224			ec.Errorf(ctx, "must not be null")
7225		}
7226		return graphql.Null
7227	}
7228	res := resTmp.(int)
7229	rctx.Result = res
7230	ctx = ec.Tracer.StartFieldChildExecution(ctx)
7231	return graphql.MarshalInt(res)
7232}
7233
7234var timelineItemEdgeImplementors = []string{"TimelineItemEdge"}
7235
7236// nolint: gocyclo, errcheck, gas, goconst
7237func (ec *executionContext) _TimelineItemEdge(ctx context.Context, sel ast.SelectionSet, obj *models.TimelineItemEdge) graphql.Marshaler {
7238	fields := graphql.CollectFields(ctx, sel, timelineItemEdgeImplementors)
7239
7240	out := graphql.NewOrderedMap(len(fields))
7241	invalid := false
7242	for i, field := range fields {
7243		out.Keys[i] = field.Alias
7244
7245		switch field.Name {
7246		case "__typename":
7247			out.Values[i] = graphql.MarshalString("TimelineItemEdge")
7248		case "cursor":
7249			out.Values[i] = ec._TimelineItemEdge_cursor(ctx, field, obj)
7250			if out.Values[i] == graphql.Null {
7251				invalid = true
7252			}
7253		case "node":
7254			out.Values[i] = ec._TimelineItemEdge_node(ctx, field, obj)
7255			if out.Values[i] == graphql.Null {
7256				invalid = true
7257			}
7258		default:
7259			panic("unknown field " + strconv.Quote(field.Name))
7260		}
7261	}
7262
7263	if invalid {
7264		return graphql.Null
7265	}
7266	return out
7267}
7268
7269// nolint: vetshadow
7270func (ec *executionContext) _TimelineItemEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemEdge) graphql.Marshaler {
7271	ctx = ec.Tracer.StartFieldExecution(ctx, field)
7272	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7273	rctx := &graphql.ResolverContext{
7274		Object: "TimelineItemEdge",
7275		Args:   nil,
7276		Field:  field,
7277	}
7278	ctx = graphql.WithResolverContext(ctx, rctx)
7279	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7280	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7281		ctx = rctx // use context from middleware stack in children
7282		return obj.Cursor, nil
7283	})
7284	if resTmp == nil {
7285		if !ec.HasError(rctx) {
7286			ec.Errorf(ctx, "must not be null")
7287		}
7288		return graphql.Null
7289	}
7290	res := resTmp.(string)
7291	rctx.Result = res
7292	ctx = ec.Tracer.StartFieldChildExecution(ctx)
7293	return graphql.MarshalString(res)
7294}
7295
7296// nolint: vetshadow
7297func (ec *executionContext) _TimelineItemEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemEdge) graphql.Marshaler {
7298	ctx = ec.Tracer.StartFieldExecution(ctx, field)
7299	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7300	rctx := &graphql.ResolverContext{
7301		Object: "TimelineItemEdge",
7302		Args:   nil,
7303		Field:  field,
7304	}
7305	ctx = graphql.WithResolverContext(ctx, rctx)
7306	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7307	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7308		ctx = rctx // use context from middleware stack in children
7309		return obj.Node, nil
7310	})
7311	if resTmp == nil {
7312		if !ec.HasError(rctx) {
7313			ec.Errorf(ctx, "must not be null")
7314		}
7315		return graphql.Null
7316	}
7317	res := resTmp.(bug.TimelineItem)
7318	rctx.Result = res
7319	ctx = ec.Tracer.StartFieldChildExecution(ctx)
7320
7321	return ec._TimelineItem(ctx, field.Selections, &res)
7322}
7323
7324var __DirectiveImplementors = []string{"__Directive"}
7325
7326// nolint: gocyclo, errcheck, gas, goconst
7327func (ec *executionContext) ___Directive(ctx context.Context, sel ast.SelectionSet, obj *introspection.Directive) graphql.Marshaler {
7328	fields := graphql.CollectFields(ctx, sel, __DirectiveImplementors)
7329
7330	out := graphql.NewOrderedMap(len(fields))
7331	invalid := false
7332	for i, field := range fields {
7333		out.Keys[i] = field.Alias
7334
7335		switch field.Name {
7336		case "__typename":
7337			out.Values[i] = graphql.MarshalString("__Directive")
7338		case "name":
7339			out.Values[i] = ec.___Directive_name(ctx, field, obj)
7340			if out.Values[i] == graphql.Null {
7341				invalid = true
7342			}
7343		case "description":
7344			out.Values[i] = ec.___Directive_description(ctx, field, obj)
7345		case "locations":
7346			out.Values[i] = ec.___Directive_locations(ctx, field, obj)
7347			if out.Values[i] == graphql.Null {
7348				invalid = true
7349			}
7350		case "args":
7351			out.Values[i] = ec.___Directive_args(ctx, field, obj)
7352			if out.Values[i] == graphql.Null {
7353				invalid = true
7354			}
7355		default:
7356			panic("unknown field " + strconv.Quote(field.Name))
7357		}
7358	}
7359
7360	if invalid {
7361		return graphql.Null
7362	}
7363	return out
7364}
7365
7366// nolint: vetshadow
7367func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) graphql.Marshaler {
7368	ctx = ec.Tracer.StartFieldExecution(ctx, field)
7369	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7370	rctx := &graphql.ResolverContext{
7371		Object: "__Directive",
7372		Args:   nil,
7373		Field:  field,
7374	}
7375	ctx = graphql.WithResolverContext(ctx, rctx)
7376	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7377	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7378		ctx = rctx // use context from middleware stack in children
7379		return obj.Name, nil
7380	})
7381	if resTmp == nil {
7382		if !ec.HasError(rctx) {
7383			ec.Errorf(ctx, "must not be null")
7384		}
7385		return graphql.Null
7386	}
7387	res := resTmp.(string)
7388	rctx.Result = res
7389	ctx = ec.Tracer.StartFieldChildExecution(ctx)
7390	return graphql.MarshalString(res)
7391}
7392
7393// nolint: vetshadow
7394func (ec *executionContext) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) graphql.Marshaler {
7395	ctx = ec.Tracer.StartFieldExecution(ctx, field)
7396	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7397	rctx := &graphql.ResolverContext{
7398		Object: "__Directive",
7399		Args:   nil,
7400		Field:  field,
7401	}
7402	ctx = graphql.WithResolverContext(ctx, rctx)
7403	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7404	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7405		ctx = rctx // use context from middleware stack in children
7406		return obj.Description, nil
7407	})
7408	if resTmp == nil {
7409		return graphql.Null
7410	}
7411	res := resTmp.(string)
7412	rctx.Result = res
7413	ctx = ec.Tracer.StartFieldChildExecution(ctx)
7414	return graphql.MarshalString(res)
7415}
7416
7417// nolint: vetshadow
7418func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) graphql.Marshaler {
7419	ctx = ec.Tracer.StartFieldExecution(ctx, field)
7420	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7421	rctx := &graphql.ResolverContext{
7422		Object: "__Directive",
7423		Args:   nil,
7424		Field:  field,
7425	}
7426	ctx = graphql.WithResolverContext(ctx, rctx)
7427	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7428	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7429		ctx = rctx // use context from middleware stack in children
7430		return obj.Locations, nil
7431	})
7432	if resTmp == nil {
7433		if !ec.HasError(rctx) {
7434			ec.Errorf(ctx, "must not be null")
7435		}
7436		return graphql.Null
7437	}
7438	res := resTmp.([]string)
7439	rctx.Result = res
7440	ctx = ec.Tracer.StartFieldChildExecution(ctx)
7441
7442	arr1 := make(graphql.Array, len(res))
7443
7444	for idx1 := range res {
7445		arr1[idx1] = func() graphql.Marshaler {
7446			return graphql.MarshalString(res[idx1])
7447		}()
7448	}
7449
7450	return arr1
7451}
7452
7453// nolint: vetshadow
7454func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) graphql.Marshaler {
7455	ctx = ec.Tracer.StartFieldExecution(ctx, field)
7456	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7457	rctx := &graphql.ResolverContext{
7458		Object: "__Directive",
7459		Args:   nil,
7460		Field:  field,
7461	}
7462	ctx = graphql.WithResolverContext(ctx, rctx)
7463	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7464	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7465		ctx = rctx // use context from middleware stack in children
7466		return obj.Args, nil
7467	})
7468	if resTmp == nil {
7469		if !ec.HasError(rctx) {
7470			ec.Errorf(ctx, "must not be null")
7471		}
7472		return graphql.Null
7473	}
7474	res := resTmp.([]introspection.InputValue)
7475	rctx.Result = res
7476	ctx = ec.Tracer.StartFieldChildExecution(ctx)
7477
7478	arr1 := make(graphql.Array, len(res))
7479	var wg sync.WaitGroup
7480
7481	isLen1 := len(res) == 1
7482	if !isLen1 {
7483		wg.Add(len(res))
7484	}
7485
7486	for idx1 := range res {
7487		idx1 := idx1
7488		rctx := &graphql.ResolverContext{
7489			Index:  &idx1,
7490			Result: &res[idx1],
7491		}
7492		ctx := graphql.WithResolverContext(ctx, rctx)
7493		f := func(idx1 int) {
7494			if !isLen1 {
7495				defer wg.Done()
7496			}
7497			arr1[idx1] = func() graphql.Marshaler {
7498
7499				return ec.___InputValue(ctx, field.Selections, &res[idx1])
7500			}()
7501		}
7502		if isLen1 {
7503			f(idx1)
7504		} else {
7505			go f(idx1)
7506		}
7507
7508	}
7509	wg.Wait()
7510	return arr1
7511}
7512
7513var __EnumValueImplementors = []string{"__EnumValue"}
7514
7515// nolint: gocyclo, errcheck, gas, goconst
7516func (ec *executionContext) ___EnumValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.EnumValue) graphql.Marshaler {
7517	fields := graphql.CollectFields(ctx, sel, __EnumValueImplementors)
7518
7519	out := graphql.NewOrderedMap(len(fields))
7520	invalid := false
7521	for i, field := range fields {
7522		out.Keys[i] = field.Alias
7523
7524		switch field.Name {
7525		case "__typename":
7526			out.Values[i] = graphql.MarshalString("__EnumValue")
7527		case "name":
7528			out.Values[i] = ec.___EnumValue_name(ctx, field, obj)
7529			if out.Values[i] == graphql.Null {
7530				invalid = true
7531			}
7532		case "description":
7533			out.Values[i] = ec.___EnumValue_description(ctx, field, obj)
7534		case "isDeprecated":
7535			out.Values[i] = ec.___EnumValue_isDeprecated(ctx, field, obj)
7536			if out.Values[i] == graphql.Null {
7537				invalid = true
7538			}
7539		case "deprecationReason":
7540			out.Values[i] = ec.___EnumValue_deprecationReason(ctx, field, obj)
7541		default:
7542			panic("unknown field " + strconv.Quote(field.Name))
7543		}
7544	}
7545
7546	if invalid {
7547		return graphql.Null
7548	}
7549	return out
7550}
7551
7552// nolint: vetshadow
7553func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) graphql.Marshaler {
7554	ctx = ec.Tracer.StartFieldExecution(ctx, field)
7555	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7556	rctx := &graphql.ResolverContext{
7557		Object: "__EnumValue",
7558		Args:   nil,
7559		Field:  field,
7560	}
7561	ctx = graphql.WithResolverContext(ctx, rctx)
7562	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7563	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7564		ctx = rctx // use context from middleware stack in children
7565		return obj.Name, nil
7566	})
7567	if resTmp == nil {
7568		if !ec.HasError(rctx) {
7569			ec.Errorf(ctx, "must not be null")
7570		}
7571		return graphql.Null
7572	}
7573	res := resTmp.(string)
7574	rctx.Result = res
7575	ctx = ec.Tracer.StartFieldChildExecution(ctx)
7576	return graphql.MarshalString(res)
7577}
7578
7579// nolint: vetshadow
7580func (ec *executionContext) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) graphql.Marshaler {
7581	ctx = ec.Tracer.StartFieldExecution(ctx, field)
7582	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7583	rctx := &graphql.ResolverContext{
7584		Object: "__EnumValue",
7585		Args:   nil,
7586		Field:  field,
7587	}
7588	ctx = graphql.WithResolverContext(ctx, rctx)
7589	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7590	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7591		ctx = rctx // use context from middleware stack in children
7592		return obj.Description, nil
7593	})
7594	if resTmp == nil {
7595		return graphql.Null
7596	}
7597	res := resTmp.(string)
7598	rctx.Result = res
7599	ctx = ec.Tracer.StartFieldChildExecution(ctx)
7600	return graphql.MarshalString(res)
7601}
7602
7603// nolint: vetshadow
7604func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) graphql.Marshaler {
7605	ctx = ec.Tracer.StartFieldExecution(ctx, field)
7606	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7607	rctx := &graphql.ResolverContext{
7608		Object: "__EnumValue",
7609		Args:   nil,
7610		Field:  field,
7611	}
7612	ctx = graphql.WithResolverContext(ctx, rctx)
7613	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7614	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7615		ctx = rctx // use context from middleware stack in children
7616		return obj.IsDeprecated(), nil
7617	})
7618	if resTmp == nil {
7619		if !ec.HasError(rctx) {
7620			ec.Errorf(ctx, "must not be null")
7621		}
7622		return graphql.Null
7623	}
7624	res := resTmp.(bool)
7625	rctx.Result = res
7626	ctx = ec.Tracer.StartFieldChildExecution(ctx)
7627	return graphql.MarshalBoolean(res)
7628}
7629
7630// nolint: vetshadow
7631func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) graphql.Marshaler {
7632	ctx = ec.Tracer.StartFieldExecution(ctx, field)
7633	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7634	rctx := &graphql.ResolverContext{
7635		Object: "__EnumValue",
7636		Args:   nil,
7637		Field:  field,
7638	}
7639	ctx = graphql.WithResolverContext(ctx, rctx)
7640	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7641	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7642		ctx = rctx // use context from middleware stack in children
7643		return obj.DeprecationReason(), nil
7644	})
7645	if resTmp == nil {
7646		return graphql.Null
7647	}
7648	res := resTmp.(*string)
7649	rctx.Result = res
7650	ctx = ec.Tracer.StartFieldChildExecution(ctx)
7651
7652	if res == nil {
7653		return graphql.Null
7654	}
7655	return graphql.MarshalString(*res)
7656}
7657
7658var __FieldImplementors = []string{"__Field"}
7659
7660// nolint: gocyclo, errcheck, gas, goconst
7661func (ec *executionContext) ___Field(ctx context.Context, sel ast.SelectionSet, obj *introspection.Field) graphql.Marshaler {
7662	fields := graphql.CollectFields(ctx, sel, __FieldImplementors)
7663
7664	out := graphql.NewOrderedMap(len(fields))
7665	invalid := false
7666	for i, field := range fields {
7667		out.Keys[i] = field.Alias
7668
7669		switch field.Name {
7670		case "__typename":
7671			out.Values[i] = graphql.MarshalString("__Field")
7672		case "name":
7673			out.Values[i] = ec.___Field_name(ctx, field, obj)
7674			if out.Values[i] == graphql.Null {
7675				invalid = true
7676			}
7677		case "description":
7678			out.Values[i] = ec.___Field_description(ctx, field, obj)
7679		case "args":
7680			out.Values[i] = ec.___Field_args(ctx, field, obj)
7681			if out.Values[i] == graphql.Null {
7682				invalid = true
7683			}
7684		case "type":
7685			out.Values[i] = ec.___Field_type(ctx, field, obj)
7686			if out.Values[i] == graphql.Null {
7687				invalid = true
7688			}
7689		case "isDeprecated":
7690			out.Values[i] = ec.___Field_isDeprecated(ctx, field, obj)
7691			if out.Values[i] == graphql.Null {
7692				invalid = true
7693			}
7694		case "deprecationReason":
7695			out.Values[i] = ec.___Field_deprecationReason(ctx, field, obj)
7696		default:
7697			panic("unknown field " + strconv.Quote(field.Name))
7698		}
7699	}
7700
7701	if invalid {
7702		return graphql.Null
7703	}
7704	return out
7705}
7706
7707// nolint: vetshadow
7708func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) graphql.Marshaler {
7709	ctx = ec.Tracer.StartFieldExecution(ctx, field)
7710	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7711	rctx := &graphql.ResolverContext{
7712		Object: "__Field",
7713		Args:   nil,
7714		Field:  field,
7715	}
7716	ctx = graphql.WithResolverContext(ctx, rctx)
7717	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7718	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7719		ctx = rctx // use context from middleware stack in children
7720		return obj.Name, nil
7721	})
7722	if resTmp == nil {
7723		if !ec.HasError(rctx) {
7724			ec.Errorf(ctx, "must not be null")
7725		}
7726		return graphql.Null
7727	}
7728	res := resTmp.(string)
7729	rctx.Result = res
7730	ctx = ec.Tracer.StartFieldChildExecution(ctx)
7731	return graphql.MarshalString(res)
7732}
7733
7734// nolint: vetshadow
7735func (ec *executionContext) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) graphql.Marshaler {
7736	ctx = ec.Tracer.StartFieldExecution(ctx, field)
7737	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7738	rctx := &graphql.ResolverContext{
7739		Object: "__Field",
7740		Args:   nil,
7741		Field:  field,
7742	}
7743	ctx = graphql.WithResolverContext(ctx, rctx)
7744	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7745	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7746		ctx = rctx // use context from middleware stack in children
7747		return obj.Description, nil
7748	})
7749	if resTmp == nil {
7750		return graphql.Null
7751	}
7752	res := resTmp.(string)
7753	rctx.Result = res
7754	ctx = ec.Tracer.StartFieldChildExecution(ctx)
7755	return graphql.MarshalString(res)
7756}
7757
7758// nolint: vetshadow
7759func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) graphql.Marshaler {
7760	ctx = ec.Tracer.StartFieldExecution(ctx, field)
7761	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7762	rctx := &graphql.ResolverContext{
7763		Object: "__Field",
7764		Args:   nil,
7765		Field:  field,
7766	}
7767	ctx = graphql.WithResolverContext(ctx, rctx)
7768	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7769	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7770		ctx = rctx // use context from middleware stack in children
7771		return obj.Args, nil
7772	})
7773	if resTmp == nil {
7774		if !ec.HasError(rctx) {
7775			ec.Errorf(ctx, "must not be null")
7776		}
7777		return graphql.Null
7778	}
7779	res := resTmp.([]introspection.InputValue)
7780	rctx.Result = res
7781	ctx = ec.Tracer.StartFieldChildExecution(ctx)
7782
7783	arr1 := make(graphql.Array, len(res))
7784	var wg sync.WaitGroup
7785
7786	isLen1 := len(res) == 1
7787	if !isLen1 {
7788		wg.Add(len(res))
7789	}
7790
7791	for idx1 := range res {
7792		idx1 := idx1
7793		rctx := &graphql.ResolverContext{
7794			Index:  &idx1,
7795			Result: &res[idx1],
7796		}
7797		ctx := graphql.WithResolverContext(ctx, rctx)
7798		f := func(idx1 int) {
7799			if !isLen1 {
7800				defer wg.Done()
7801			}
7802			arr1[idx1] = func() graphql.Marshaler {
7803
7804				return ec.___InputValue(ctx, field.Selections, &res[idx1])
7805			}()
7806		}
7807		if isLen1 {
7808			f(idx1)
7809		} else {
7810			go f(idx1)
7811		}
7812
7813	}
7814	wg.Wait()
7815	return arr1
7816}
7817
7818// nolint: vetshadow
7819func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) graphql.Marshaler {
7820	ctx = ec.Tracer.StartFieldExecution(ctx, field)
7821	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7822	rctx := &graphql.ResolverContext{
7823		Object: "__Field",
7824		Args:   nil,
7825		Field:  field,
7826	}
7827	ctx = graphql.WithResolverContext(ctx, rctx)
7828	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7829	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7830		ctx = rctx // use context from middleware stack in children
7831		return obj.Type, nil
7832	})
7833	if resTmp == nil {
7834		if !ec.HasError(rctx) {
7835			ec.Errorf(ctx, "must not be null")
7836		}
7837		return graphql.Null
7838	}
7839	res := resTmp.(*introspection.Type)
7840	rctx.Result = res
7841	ctx = ec.Tracer.StartFieldChildExecution(ctx)
7842
7843	if res == nil {
7844		if !ec.HasError(rctx) {
7845			ec.Errorf(ctx, "must not be null")
7846		}
7847		return graphql.Null
7848	}
7849
7850	return ec.___Type(ctx, field.Selections, res)
7851}
7852
7853// nolint: vetshadow
7854func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) graphql.Marshaler {
7855	ctx = ec.Tracer.StartFieldExecution(ctx, field)
7856	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7857	rctx := &graphql.ResolverContext{
7858		Object: "__Field",
7859		Args:   nil,
7860		Field:  field,
7861	}
7862	ctx = graphql.WithResolverContext(ctx, rctx)
7863	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7864	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7865		ctx = rctx // use context from middleware stack in children
7866		return obj.IsDeprecated(), nil
7867	})
7868	if resTmp == nil {
7869		if !ec.HasError(rctx) {
7870			ec.Errorf(ctx, "must not be null")
7871		}
7872		return graphql.Null
7873	}
7874	res := resTmp.(bool)
7875	rctx.Result = res
7876	ctx = ec.Tracer.StartFieldChildExecution(ctx)
7877	return graphql.MarshalBoolean(res)
7878}
7879
7880// nolint: vetshadow
7881func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) graphql.Marshaler {
7882	ctx = ec.Tracer.StartFieldExecution(ctx, field)
7883	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7884	rctx := &graphql.ResolverContext{
7885		Object: "__Field",
7886		Args:   nil,
7887		Field:  field,
7888	}
7889	ctx = graphql.WithResolverContext(ctx, rctx)
7890	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7891	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7892		ctx = rctx // use context from middleware stack in children
7893		return obj.DeprecationReason(), nil
7894	})
7895	if resTmp == nil {
7896		return graphql.Null
7897	}
7898	res := resTmp.(*string)
7899	rctx.Result = res
7900	ctx = ec.Tracer.StartFieldChildExecution(ctx)
7901
7902	if res == nil {
7903		return graphql.Null
7904	}
7905	return graphql.MarshalString(*res)
7906}
7907
7908var __InputValueImplementors = []string{"__InputValue"}
7909
7910// nolint: gocyclo, errcheck, gas, goconst
7911func (ec *executionContext) ___InputValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.InputValue) graphql.Marshaler {
7912	fields := graphql.CollectFields(ctx, sel, __InputValueImplementors)
7913
7914	out := graphql.NewOrderedMap(len(fields))
7915	invalid := false
7916	for i, field := range fields {
7917		out.Keys[i] = field.Alias
7918
7919		switch field.Name {
7920		case "__typename":
7921			out.Values[i] = graphql.MarshalString("__InputValue")
7922		case "name":
7923			out.Values[i] = ec.___InputValue_name(ctx, field, obj)
7924			if out.Values[i] == graphql.Null {
7925				invalid = true
7926			}
7927		case "description":
7928			out.Values[i] = ec.___InputValue_description(ctx, field, obj)
7929		case "type":
7930			out.Values[i] = ec.___InputValue_type(ctx, field, obj)
7931			if out.Values[i] == graphql.Null {
7932				invalid = true
7933			}
7934		case "defaultValue":
7935			out.Values[i] = ec.___InputValue_defaultValue(ctx, field, obj)
7936		default:
7937			panic("unknown field " + strconv.Quote(field.Name))
7938		}
7939	}
7940
7941	if invalid {
7942		return graphql.Null
7943	}
7944	return out
7945}
7946
7947// nolint: vetshadow
7948func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) graphql.Marshaler {
7949	ctx = ec.Tracer.StartFieldExecution(ctx, field)
7950	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7951	rctx := &graphql.ResolverContext{
7952		Object: "__InputValue",
7953		Args:   nil,
7954		Field:  field,
7955	}
7956	ctx = graphql.WithResolverContext(ctx, rctx)
7957	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7958	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7959		ctx = rctx // use context from middleware stack in children
7960		return obj.Name, nil
7961	})
7962	if resTmp == nil {
7963		if !ec.HasError(rctx) {
7964			ec.Errorf(ctx, "must not be null")
7965		}
7966		return graphql.Null
7967	}
7968	res := resTmp.(string)
7969	rctx.Result = res
7970	ctx = ec.Tracer.StartFieldChildExecution(ctx)
7971	return graphql.MarshalString(res)
7972}
7973
7974// nolint: vetshadow
7975func (ec *executionContext) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) graphql.Marshaler {
7976	ctx = ec.Tracer.StartFieldExecution(ctx, field)
7977	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
7978	rctx := &graphql.ResolverContext{
7979		Object: "__InputValue",
7980		Args:   nil,
7981		Field:  field,
7982	}
7983	ctx = graphql.WithResolverContext(ctx, rctx)
7984	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
7985	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
7986		ctx = rctx // use context from middleware stack in children
7987		return obj.Description, nil
7988	})
7989	if resTmp == nil {
7990		return graphql.Null
7991	}
7992	res := resTmp.(string)
7993	rctx.Result = res
7994	ctx = ec.Tracer.StartFieldChildExecution(ctx)
7995	return graphql.MarshalString(res)
7996}
7997
7998// nolint: vetshadow
7999func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) graphql.Marshaler {
8000	ctx = ec.Tracer.StartFieldExecution(ctx, field)
8001	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8002	rctx := &graphql.ResolverContext{
8003		Object: "__InputValue",
8004		Args:   nil,
8005		Field:  field,
8006	}
8007	ctx = graphql.WithResolverContext(ctx, rctx)
8008	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8009	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8010		ctx = rctx // use context from middleware stack in children
8011		return obj.Type, nil
8012	})
8013	if resTmp == nil {
8014		if !ec.HasError(rctx) {
8015			ec.Errorf(ctx, "must not be null")
8016		}
8017		return graphql.Null
8018	}
8019	res := resTmp.(*introspection.Type)
8020	rctx.Result = res
8021	ctx = ec.Tracer.StartFieldChildExecution(ctx)
8022
8023	if res == nil {
8024		if !ec.HasError(rctx) {
8025			ec.Errorf(ctx, "must not be null")
8026		}
8027		return graphql.Null
8028	}
8029
8030	return ec.___Type(ctx, field.Selections, res)
8031}
8032
8033// nolint: vetshadow
8034func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) graphql.Marshaler {
8035	ctx = ec.Tracer.StartFieldExecution(ctx, field)
8036	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8037	rctx := &graphql.ResolverContext{
8038		Object: "__InputValue",
8039		Args:   nil,
8040		Field:  field,
8041	}
8042	ctx = graphql.WithResolverContext(ctx, rctx)
8043	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8044	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8045		ctx = rctx // use context from middleware stack in children
8046		return obj.DefaultValue, nil
8047	})
8048	if resTmp == nil {
8049		return graphql.Null
8050	}
8051	res := resTmp.(*string)
8052	rctx.Result = res
8053	ctx = ec.Tracer.StartFieldChildExecution(ctx)
8054
8055	if res == nil {
8056		return graphql.Null
8057	}
8058	return graphql.MarshalString(*res)
8059}
8060
8061var __SchemaImplementors = []string{"__Schema"}
8062
8063// nolint: gocyclo, errcheck, gas, goconst
8064func (ec *executionContext) ___Schema(ctx context.Context, sel ast.SelectionSet, obj *introspection.Schema) graphql.Marshaler {
8065	fields := graphql.CollectFields(ctx, sel, __SchemaImplementors)
8066
8067	out := graphql.NewOrderedMap(len(fields))
8068	invalid := false
8069	for i, field := range fields {
8070		out.Keys[i] = field.Alias
8071
8072		switch field.Name {
8073		case "__typename":
8074			out.Values[i] = graphql.MarshalString("__Schema")
8075		case "types":
8076			out.Values[i] = ec.___Schema_types(ctx, field, obj)
8077			if out.Values[i] == graphql.Null {
8078				invalid = true
8079			}
8080		case "queryType":
8081			out.Values[i] = ec.___Schema_queryType(ctx, field, obj)
8082			if out.Values[i] == graphql.Null {
8083				invalid = true
8084			}
8085		case "mutationType":
8086			out.Values[i] = ec.___Schema_mutationType(ctx, field, obj)
8087		case "subscriptionType":
8088			out.Values[i] = ec.___Schema_subscriptionType(ctx, field, obj)
8089		case "directives":
8090			out.Values[i] = ec.___Schema_directives(ctx, field, obj)
8091			if out.Values[i] == graphql.Null {
8092				invalid = true
8093			}
8094		default:
8095			panic("unknown field " + strconv.Quote(field.Name))
8096		}
8097	}
8098
8099	if invalid {
8100		return graphql.Null
8101	}
8102	return out
8103}
8104
8105// nolint: vetshadow
8106func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) graphql.Marshaler {
8107	ctx = ec.Tracer.StartFieldExecution(ctx, field)
8108	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8109	rctx := &graphql.ResolverContext{
8110		Object: "__Schema",
8111		Args:   nil,
8112		Field:  field,
8113	}
8114	ctx = graphql.WithResolverContext(ctx, rctx)
8115	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8116	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8117		ctx = rctx // use context from middleware stack in children
8118		return obj.Types(), nil
8119	})
8120	if resTmp == nil {
8121		if !ec.HasError(rctx) {
8122			ec.Errorf(ctx, "must not be null")
8123		}
8124		return graphql.Null
8125	}
8126	res := resTmp.([]introspection.Type)
8127	rctx.Result = res
8128	ctx = ec.Tracer.StartFieldChildExecution(ctx)
8129
8130	arr1 := make(graphql.Array, len(res))
8131	var wg sync.WaitGroup
8132
8133	isLen1 := len(res) == 1
8134	if !isLen1 {
8135		wg.Add(len(res))
8136	}
8137
8138	for idx1 := range res {
8139		idx1 := idx1
8140		rctx := &graphql.ResolverContext{
8141			Index:  &idx1,
8142			Result: &res[idx1],
8143		}
8144		ctx := graphql.WithResolverContext(ctx, rctx)
8145		f := func(idx1 int) {
8146			if !isLen1 {
8147				defer wg.Done()
8148			}
8149			arr1[idx1] = func() graphql.Marshaler {
8150
8151				return ec.___Type(ctx, field.Selections, &res[idx1])
8152			}()
8153		}
8154		if isLen1 {
8155			f(idx1)
8156		} else {
8157			go f(idx1)
8158		}
8159
8160	}
8161	wg.Wait()
8162	return arr1
8163}
8164
8165// nolint: vetshadow
8166func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) graphql.Marshaler {
8167	ctx = ec.Tracer.StartFieldExecution(ctx, field)
8168	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8169	rctx := &graphql.ResolverContext{
8170		Object: "__Schema",
8171		Args:   nil,
8172		Field:  field,
8173	}
8174	ctx = graphql.WithResolverContext(ctx, rctx)
8175	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8176	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8177		ctx = rctx // use context from middleware stack in children
8178		return obj.QueryType(), nil
8179	})
8180	if resTmp == nil {
8181		if !ec.HasError(rctx) {
8182			ec.Errorf(ctx, "must not be null")
8183		}
8184		return graphql.Null
8185	}
8186	res := resTmp.(*introspection.Type)
8187	rctx.Result = res
8188	ctx = ec.Tracer.StartFieldChildExecution(ctx)
8189
8190	if res == nil {
8191		if !ec.HasError(rctx) {
8192			ec.Errorf(ctx, "must not be null")
8193		}
8194		return graphql.Null
8195	}
8196
8197	return ec.___Type(ctx, field.Selections, res)
8198}
8199
8200// nolint: vetshadow
8201func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) graphql.Marshaler {
8202	ctx = ec.Tracer.StartFieldExecution(ctx, field)
8203	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8204	rctx := &graphql.ResolverContext{
8205		Object: "__Schema",
8206		Args:   nil,
8207		Field:  field,
8208	}
8209	ctx = graphql.WithResolverContext(ctx, rctx)
8210	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8211	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8212		ctx = rctx // use context from middleware stack in children
8213		return obj.MutationType(), nil
8214	})
8215	if resTmp == nil {
8216		return graphql.Null
8217	}
8218	res := resTmp.(*introspection.Type)
8219	rctx.Result = res
8220	ctx = ec.Tracer.StartFieldChildExecution(ctx)
8221
8222	if res == nil {
8223		return graphql.Null
8224	}
8225
8226	return ec.___Type(ctx, field.Selections, res)
8227}
8228
8229// nolint: vetshadow
8230func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) graphql.Marshaler {
8231	ctx = ec.Tracer.StartFieldExecution(ctx, field)
8232	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8233	rctx := &graphql.ResolverContext{
8234		Object: "__Schema",
8235		Args:   nil,
8236		Field:  field,
8237	}
8238	ctx = graphql.WithResolverContext(ctx, rctx)
8239	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8240	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8241		ctx = rctx // use context from middleware stack in children
8242		return obj.SubscriptionType(), nil
8243	})
8244	if resTmp == nil {
8245		return graphql.Null
8246	}
8247	res := resTmp.(*introspection.Type)
8248	rctx.Result = res
8249	ctx = ec.Tracer.StartFieldChildExecution(ctx)
8250
8251	if res == nil {
8252		return graphql.Null
8253	}
8254
8255	return ec.___Type(ctx, field.Selections, res)
8256}
8257
8258// nolint: vetshadow
8259func (ec *executionContext) ___Schema_directives(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) graphql.Marshaler {
8260	ctx = ec.Tracer.StartFieldExecution(ctx, field)
8261	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8262	rctx := &graphql.ResolverContext{
8263		Object: "__Schema",
8264		Args:   nil,
8265		Field:  field,
8266	}
8267	ctx = graphql.WithResolverContext(ctx, rctx)
8268	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8269	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8270		ctx = rctx // use context from middleware stack in children
8271		return obj.Directives(), nil
8272	})
8273	if resTmp == nil {
8274		if !ec.HasError(rctx) {
8275			ec.Errorf(ctx, "must not be null")
8276		}
8277		return graphql.Null
8278	}
8279	res := resTmp.([]introspection.Directive)
8280	rctx.Result = res
8281	ctx = ec.Tracer.StartFieldChildExecution(ctx)
8282
8283	arr1 := make(graphql.Array, len(res))
8284	var wg sync.WaitGroup
8285
8286	isLen1 := len(res) == 1
8287	if !isLen1 {
8288		wg.Add(len(res))
8289	}
8290
8291	for idx1 := range res {
8292		idx1 := idx1
8293		rctx := &graphql.ResolverContext{
8294			Index:  &idx1,
8295			Result: &res[idx1],
8296		}
8297		ctx := graphql.WithResolverContext(ctx, rctx)
8298		f := func(idx1 int) {
8299			if !isLen1 {
8300				defer wg.Done()
8301			}
8302			arr1[idx1] = func() graphql.Marshaler {
8303
8304				return ec.___Directive(ctx, field.Selections, &res[idx1])
8305			}()
8306		}
8307		if isLen1 {
8308			f(idx1)
8309		} else {
8310			go f(idx1)
8311		}
8312
8313	}
8314	wg.Wait()
8315	return arr1
8316}
8317
8318var __TypeImplementors = []string{"__Type"}
8319
8320// nolint: gocyclo, errcheck, gas, goconst
8321func (ec *executionContext) ___Type(ctx context.Context, sel ast.SelectionSet, obj *introspection.Type) graphql.Marshaler {
8322	fields := graphql.CollectFields(ctx, sel, __TypeImplementors)
8323
8324	out := graphql.NewOrderedMap(len(fields))
8325	invalid := false
8326	for i, field := range fields {
8327		out.Keys[i] = field.Alias
8328
8329		switch field.Name {
8330		case "__typename":
8331			out.Values[i] = graphql.MarshalString("__Type")
8332		case "kind":
8333			out.Values[i] = ec.___Type_kind(ctx, field, obj)
8334			if out.Values[i] == graphql.Null {
8335				invalid = true
8336			}
8337		case "name":
8338			out.Values[i] = ec.___Type_name(ctx, field, obj)
8339		case "description":
8340			out.Values[i] = ec.___Type_description(ctx, field, obj)
8341		case "fields":
8342			out.Values[i] = ec.___Type_fields(ctx, field, obj)
8343		case "interfaces":
8344			out.Values[i] = ec.___Type_interfaces(ctx, field, obj)
8345		case "possibleTypes":
8346			out.Values[i] = ec.___Type_possibleTypes(ctx, field, obj)
8347		case "enumValues":
8348			out.Values[i] = ec.___Type_enumValues(ctx, field, obj)
8349		case "inputFields":
8350			out.Values[i] = ec.___Type_inputFields(ctx, field, obj)
8351		case "ofType":
8352			out.Values[i] = ec.___Type_ofType(ctx, field, obj)
8353		default:
8354			panic("unknown field " + strconv.Quote(field.Name))
8355		}
8356	}
8357
8358	if invalid {
8359		return graphql.Null
8360	}
8361	return out
8362}
8363
8364// nolint: vetshadow
8365func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler {
8366	ctx = ec.Tracer.StartFieldExecution(ctx, field)
8367	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8368	rctx := &graphql.ResolverContext{
8369		Object: "__Type",
8370		Args:   nil,
8371		Field:  field,
8372	}
8373	ctx = graphql.WithResolverContext(ctx, rctx)
8374	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8375	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8376		ctx = rctx // use context from middleware stack in children
8377		return obj.Kind(), nil
8378	})
8379	if resTmp == nil {
8380		if !ec.HasError(rctx) {
8381			ec.Errorf(ctx, "must not be null")
8382		}
8383		return graphql.Null
8384	}
8385	res := resTmp.(string)
8386	rctx.Result = res
8387	ctx = ec.Tracer.StartFieldChildExecution(ctx)
8388	return graphql.MarshalString(res)
8389}
8390
8391// nolint: vetshadow
8392func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler {
8393	ctx = ec.Tracer.StartFieldExecution(ctx, field)
8394	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8395	rctx := &graphql.ResolverContext{
8396		Object: "__Type",
8397		Args:   nil,
8398		Field:  field,
8399	}
8400	ctx = graphql.WithResolverContext(ctx, rctx)
8401	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8402	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8403		ctx = rctx // use context from middleware stack in children
8404		return obj.Name(), nil
8405	})
8406	if resTmp == nil {
8407		return graphql.Null
8408	}
8409	res := resTmp.(*string)
8410	rctx.Result = res
8411	ctx = ec.Tracer.StartFieldChildExecution(ctx)
8412
8413	if res == nil {
8414		return graphql.Null
8415	}
8416	return graphql.MarshalString(*res)
8417}
8418
8419// nolint: vetshadow
8420func (ec *executionContext) ___Type_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler {
8421	ctx = ec.Tracer.StartFieldExecution(ctx, field)
8422	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8423	rctx := &graphql.ResolverContext{
8424		Object: "__Type",
8425		Args:   nil,
8426		Field:  field,
8427	}
8428	ctx = graphql.WithResolverContext(ctx, rctx)
8429	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8430	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8431		ctx = rctx // use context from middleware stack in children
8432		return obj.Description(), nil
8433	})
8434	if resTmp == nil {
8435		return graphql.Null
8436	}
8437	res := resTmp.(string)
8438	rctx.Result = res
8439	ctx = ec.Tracer.StartFieldChildExecution(ctx)
8440	return graphql.MarshalString(res)
8441}
8442
8443// nolint: vetshadow
8444func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler {
8445	ctx = ec.Tracer.StartFieldExecution(ctx, field)
8446	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8447	rawArgs := field.ArgumentMap(ec.Variables)
8448	args, err := field___Type_fields_args(rawArgs)
8449	if err != nil {
8450		ec.Error(ctx, err)
8451		return graphql.Null
8452	}
8453	rctx := &graphql.ResolverContext{
8454		Object: "__Type",
8455		Args:   args,
8456		Field:  field,
8457	}
8458	ctx = graphql.WithResolverContext(ctx, rctx)
8459	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8460	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8461		ctx = rctx // use context from middleware stack in children
8462		return obj.Fields(args["includeDeprecated"].(bool)), nil
8463	})
8464	if resTmp == nil {
8465		return graphql.Null
8466	}
8467	res := resTmp.([]introspection.Field)
8468	rctx.Result = res
8469	ctx = ec.Tracer.StartFieldChildExecution(ctx)
8470
8471	arr1 := make(graphql.Array, len(res))
8472	var wg sync.WaitGroup
8473
8474	isLen1 := len(res) == 1
8475	if !isLen1 {
8476		wg.Add(len(res))
8477	}
8478
8479	for idx1 := range res {
8480		idx1 := idx1
8481		rctx := &graphql.ResolverContext{
8482			Index:  &idx1,
8483			Result: &res[idx1],
8484		}
8485		ctx := graphql.WithResolverContext(ctx, rctx)
8486		f := func(idx1 int) {
8487			if !isLen1 {
8488				defer wg.Done()
8489			}
8490			arr1[idx1] = func() graphql.Marshaler {
8491
8492				return ec.___Field(ctx, field.Selections, &res[idx1])
8493			}()
8494		}
8495		if isLen1 {
8496			f(idx1)
8497		} else {
8498			go f(idx1)
8499		}
8500
8501	}
8502	wg.Wait()
8503	return arr1
8504}
8505
8506// nolint: vetshadow
8507func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler {
8508	ctx = ec.Tracer.StartFieldExecution(ctx, field)
8509	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8510	rctx := &graphql.ResolverContext{
8511		Object: "__Type",
8512		Args:   nil,
8513		Field:  field,
8514	}
8515	ctx = graphql.WithResolverContext(ctx, rctx)
8516	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8517	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8518		ctx = rctx // use context from middleware stack in children
8519		return obj.Interfaces(), nil
8520	})
8521	if resTmp == nil {
8522		return graphql.Null
8523	}
8524	res := resTmp.([]introspection.Type)
8525	rctx.Result = res
8526	ctx = ec.Tracer.StartFieldChildExecution(ctx)
8527
8528	arr1 := make(graphql.Array, len(res))
8529	var wg sync.WaitGroup
8530
8531	isLen1 := len(res) == 1
8532	if !isLen1 {
8533		wg.Add(len(res))
8534	}
8535
8536	for idx1 := range res {
8537		idx1 := idx1
8538		rctx := &graphql.ResolverContext{
8539			Index:  &idx1,
8540			Result: &res[idx1],
8541		}
8542		ctx := graphql.WithResolverContext(ctx, rctx)
8543		f := func(idx1 int) {
8544			if !isLen1 {
8545				defer wg.Done()
8546			}
8547			arr1[idx1] = func() graphql.Marshaler {
8548
8549				return ec.___Type(ctx, field.Selections, &res[idx1])
8550			}()
8551		}
8552		if isLen1 {
8553			f(idx1)
8554		} else {
8555			go f(idx1)
8556		}
8557
8558	}
8559	wg.Wait()
8560	return arr1
8561}
8562
8563// nolint: vetshadow
8564func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler {
8565	ctx = ec.Tracer.StartFieldExecution(ctx, field)
8566	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8567	rctx := &graphql.ResolverContext{
8568		Object: "__Type",
8569		Args:   nil,
8570		Field:  field,
8571	}
8572	ctx = graphql.WithResolverContext(ctx, rctx)
8573	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8574	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8575		ctx = rctx // use context from middleware stack in children
8576		return obj.PossibleTypes(), nil
8577	})
8578	if resTmp == nil {
8579		return graphql.Null
8580	}
8581	res := resTmp.([]introspection.Type)
8582	rctx.Result = res
8583	ctx = ec.Tracer.StartFieldChildExecution(ctx)
8584
8585	arr1 := make(graphql.Array, len(res))
8586	var wg sync.WaitGroup
8587
8588	isLen1 := len(res) == 1
8589	if !isLen1 {
8590		wg.Add(len(res))
8591	}
8592
8593	for idx1 := range res {
8594		idx1 := idx1
8595		rctx := &graphql.ResolverContext{
8596			Index:  &idx1,
8597			Result: &res[idx1],
8598		}
8599		ctx := graphql.WithResolverContext(ctx, rctx)
8600		f := func(idx1 int) {
8601			if !isLen1 {
8602				defer wg.Done()
8603			}
8604			arr1[idx1] = func() graphql.Marshaler {
8605
8606				return ec.___Type(ctx, field.Selections, &res[idx1])
8607			}()
8608		}
8609		if isLen1 {
8610			f(idx1)
8611		} else {
8612			go f(idx1)
8613		}
8614
8615	}
8616	wg.Wait()
8617	return arr1
8618}
8619
8620// nolint: vetshadow
8621func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler {
8622	ctx = ec.Tracer.StartFieldExecution(ctx, field)
8623	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8624	rawArgs := field.ArgumentMap(ec.Variables)
8625	args, err := field___Type_enumValues_args(rawArgs)
8626	if err != nil {
8627		ec.Error(ctx, err)
8628		return graphql.Null
8629	}
8630	rctx := &graphql.ResolverContext{
8631		Object: "__Type",
8632		Args:   args,
8633		Field:  field,
8634	}
8635	ctx = graphql.WithResolverContext(ctx, rctx)
8636	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8637	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8638		ctx = rctx // use context from middleware stack in children
8639		return obj.EnumValues(args["includeDeprecated"].(bool)), nil
8640	})
8641	if resTmp == nil {
8642		return graphql.Null
8643	}
8644	res := resTmp.([]introspection.EnumValue)
8645	rctx.Result = res
8646	ctx = ec.Tracer.StartFieldChildExecution(ctx)
8647
8648	arr1 := make(graphql.Array, len(res))
8649	var wg sync.WaitGroup
8650
8651	isLen1 := len(res) == 1
8652	if !isLen1 {
8653		wg.Add(len(res))
8654	}
8655
8656	for idx1 := range res {
8657		idx1 := idx1
8658		rctx := &graphql.ResolverContext{
8659			Index:  &idx1,
8660			Result: &res[idx1],
8661		}
8662		ctx := graphql.WithResolverContext(ctx, rctx)
8663		f := func(idx1 int) {
8664			if !isLen1 {
8665				defer wg.Done()
8666			}
8667			arr1[idx1] = func() graphql.Marshaler {
8668
8669				return ec.___EnumValue(ctx, field.Selections, &res[idx1])
8670			}()
8671		}
8672		if isLen1 {
8673			f(idx1)
8674		} else {
8675			go f(idx1)
8676		}
8677
8678	}
8679	wg.Wait()
8680	return arr1
8681}
8682
8683// nolint: vetshadow
8684func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler {
8685	ctx = ec.Tracer.StartFieldExecution(ctx, field)
8686	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8687	rctx := &graphql.ResolverContext{
8688		Object: "__Type",
8689		Args:   nil,
8690		Field:  field,
8691	}
8692	ctx = graphql.WithResolverContext(ctx, rctx)
8693	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8694	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8695		ctx = rctx // use context from middleware stack in children
8696		return obj.InputFields(), nil
8697	})
8698	if resTmp == nil {
8699		return graphql.Null
8700	}
8701	res := resTmp.([]introspection.InputValue)
8702	rctx.Result = res
8703	ctx = ec.Tracer.StartFieldChildExecution(ctx)
8704
8705	arr1 := make(graphql.Array, len(res))
8706	var wg sync.WaitGroup
8707
8708	isLen1 := len(res) == 1
8709	if !isLen1 {
8710		wg.Add(len(res))
8711	}
8712
8713	for idx1 := range res {
8714		idx1 := idx1
8715		rctx := &graphql.ResolverContext{
8716			Index:  &idx1,
8717			Result: &res[idx1],
8718		}
8719		ctx := graphql.WithResolverContext(ctx, rctx)
8720		f := func(idx1 int) {
8721			if !isLen1 {
8722				defer wg.Done()
8723			}
8724			arr1[idx1] = func() graphql.Marshaler {
8725
8726				return ec.___InputValue(ctx, field.Selections, &res[idx1])
8727			}()
8728		}
8729		if isLen1 {
8730			f(idx1)
8731		} else {
8732			go f(idx1)
8733		}
8734
8735	}
8736	wg.Wait()
8737	return arr1
8738}
8739
8740// nolint: vetshadow
8741func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler {
8742	ctx = ec.Tracer.StartFieldExecution(ctx, field)
8743	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
8744	rctx := &graphql.ResolverContext{
8745		Object: "__Type",
8746		Args:   nil,
8747		Field:  field,
8748	}
8749	ctx = graphql.WithResolverContext(ctx, rctx)
8750	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
8751	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
8752		ctx = rctx // use context from middleware stack in children
8753		return obj.OfType(), nil
8754	})
8755	if resTmp == nil {
8756		return graphql.Null
8757	}
8758	res := resTmp.(*introspection.Type)
8759	rctx.Result = res
8760	ctx = ec.Tracer.StartFieldChildExecution(ctx)
8761
8762	if res == nil {
8763		return graphql.Null
8764	}
8765
8766	return ec.___Type(ctx, field.Selections, res)
8767}
8768
8769func (ec *executionContext) _Authored(ctx context.Context, sel ast.SelectionSet, obj *models.Authored) graphql.Marshaler {
8770	switch obj := (*obj).(type) {
8771	case nil:
8772		return graphql.Null
8773	case bug.Comment:
8774		return ec._Comment(ctx, sel, &obj)
8775	case *bug.Comment:
8776		return ec._Comment(ctx, sel, obj)
8777	case *bug.CreateOperation:
8778		return ec._CreateOperation(ctx, sel, obj)
8779	case *bug.SetTitleOperation:
8780		return ec._SetTitleOperation(ctx, sel, obj)
8781	case *bug.AddCommentOperation:
8782		return ec._AddCommentOperation(ctx, sel, obj)
8783	case *bug.EditCommentOperation:
8784		return ec._EditCommentOperation(ctx, sel, obj)
8785	case *bug.SetStatusOperation:
8786		return ec._SetStatusOperation(ctx, sel, obj)
8787	case *bug.LabelChangeOperation:
8788		return ec._LabelChangeOperation(ctx, sel, obj)
8789	default:
8790		panic(fmt.Errorf("unexpected type %T", obj))
8791	}
8792}
8793
8794func (ec *executionContext) _Operation(ctx context.Context, sel ast.SelectionSet, obj *bug.Operation) graphql.Marshaler {
8795	switch obj := (*obj).(type) {
8796	case nil:
8797		return graphql.Null
8798	case *bug.CreateOperation:
8799		return ec._CreateOperation(ctx, sel, obj)
8800	case *bug.SetTitleOperation:
8801		return ec._SetTitleOperation(ctx, sel, obj)
8802	case *bug.AddCommentOperation:
8803		return ec._AddCommentOperation(ctx, sel, obj)
8804	case *bug.EditCommentOperation:
8805		return ec._EditCommentOperation(ctx, sel, obj)
8806	case *bug.SetStatusOperation:
8807		return ec._SetStatusOperation(ctx, sel, obj)
8808	case *bug.LabelChangeOperation:
8809		return ec._LabelChangeOperation(ctx, sel, obj)
8810	default:
8811		panic(fmt.Errorf("unexpected type %T", obj))
8812	}
8813}
8814
8815func (ec *executionContext) _TimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.TimelineItem) graphql.Marshaler {
8816	switch obj := (*obj).(type) {
8817	case nil:
8818		return graphql.Null
8819	case *bug.CreateTimelineItem:
8820		return ec._CreateTimelineItem(ctx, sel, obj)
8821	case *bug.AddCommentTimelineItem:
8822		return ec._AddCommentTimelineItem(ctx, sel, obj)
8823	case bug.LabelChangeTimelineItem:
8824		return ec._LabelChangeTimelineItem(ctx, sel, &obj)
8825	case *bug.LabelChangeTimelineItem:
8826		return ec._LabelChangeTimelineItem(ctx, sel, obj)
8827	case bug.SetStatusTimelineItem:
8828		return ec._SetStatusTimelineItem(ctx, sel, &obj)
8829	case *bug.SetStatusTimelineItem:
8830		return ec._SetStatusTimelineItem(ctx, sel, obj)
8831	case bug.SetTitleTimelineItem:
8832		return ec._SetTitleTimelineItem(ctx, sel, &obj)
8833	case *bug.SetTitleTimelineItem:
8834		return ec._SetTitleTimelineItem(ctx, sel, obj)
8835	default:
8836		panic(fmt.Errorf("unexpected type %T", obj))
8837	}
8838}
8839
8840func (ec *executionContext) FieldMiddleware(ctx context.Context, obj interface{}, next graphql.Resolver) (ret interface{}) {
8841	defer func() {
8842		if r := recover(); r != nil {
8843			ec.Error(ctx, ec.Recover(ctx, r))
8844			ret = nil
8845		}
8846	}()
8847	res, err := ec.ResolverMiddleware(ctx, next)
8848	if err != nil {
8849		ec.Error(ctx, err)
8850		return nil
8851	}
8852	return res
8853}
8854
8855func (ec *executionContext) introspectSchema() (*introspection.Schema, error) {
8856	if ec.DisableIntrospection {
8857		return nil, errors.New("introspection disabled")
8858	}
8859	return introspection.WrapSchema(parsedSchema), nil
8860}
8861
8862func (ec *executionContext) introspectType(name string) (*introspection.Type, error) {
8863	if ec.DisableIntrospection {
8864		return nil, errors.New("introspection disabled")
8865	}
8866	return introspection.WrapTypeFromDef(parsedSchema, parsedSchema.Types[name]), nil
8867}
8868
8869var parsedSchema = gqlparser.MustLoadSchema(
8870	&ast.Source{Name: "schema/bug.graphql", Input: `"""Represents a comment on a bug."""
8871type Comment implements Authored {
8872  """The author of this comment."""
8873  author: Identity!
8874
8875  """The message of this comment."""
8876  message: String!
8877
8878  """All media's hash referenced in this comment"""
8879  files: [Hash!]!
8880}
8881
8882type CommentConnection {
8883  edges: [CommentEdge!]!
8884  nodes: [Comment!]!
8885  pageInfo: PageInfo!
8886  totalCount: Int!
8887}
8888
8889type CommentEdge {
8890  cursor: String!
8891  node: Comment!
8892}
8893
8894enum Status {
8895  OPEN
8896  CLOSED
8897}
8898
8899type Bug {
8900  id: String!
8901  humanId: String!
8902  status: Status!
8903  title: String!
8904  labels: [Label!]!
8905  author: Identity!
8906  createdAt: Time!
8907  lastEdit: Time!
8908
8909  comments(
8910    """Returns the elements in the list that come after the specified cursor."""
8911    after: String
8912    """Returns the elements in the list that come before the specified cursor."""
8913    before: String
8914    """Returns the first _n_ elements from the list."""
8915    first: Int
8916    """Returns the last _n_ elements from the list."""
8917    last: Int
8918  ): CommentConnection!
8919
8920  timeline(
8921    """Returns the elements in the list that come after the specified cursor."""
8922    after: String
8923    """Returns the elements in the list that come before the specified cursor."""
8924    before: String
8925    """Returns the first _n_ elements from the list."""
8926    first: Int
8927    """Returns the last _n_ elements from the list."""
8928    last: Int
8929  ): TimelineItemConnection!
8930
8931  operations(
8932    """Returns the elements in the list that come after the specified cursor."""
8933    after: String
8934    """Returns the elements in the list that come before the specified cursor."""
8935    before: String
8936    """Returns the first _n_ elements from the list."""
8937    first: Int
8938    """Returns the last _n_ elements from the list."""
8939    last: Int
8940  ): OperationConnection!
8941}
8942
8943"""The connection type for Bug."""
8944type BugConnection {
8945  """A list of edges."""
8946  edges: [BugEdge!]!
8947  nodes: [Bug!]!
8948  """Information to aid in pagination."""
8949  pageInfo: PageInfo!
8950  """Identifies the total count of items in the connection."""
8951  totalCount: Int!
8952}
8953
8954"""An edge in a connection."""
8955type BugEdge {
8956  """A cursor for use in pagination."""
8957  cursor: String!
8958  """The item at the end of the edge."""
8959  node: Bug!
8960}
8961
8962type Repository {
8963  allBugs(
8964    """Returns the elements in the list that come after the specified cursor."""
8965    after: String
8966    """Returns the elements in the list that come before the specified cursor."""
8967    before: String
8968    """Returns the first _n_ elements from the list."""
8969    first: Int
8970    """Returns the last _n_ elements from the list."""
8971    last: Int
8972    """A query to select and order bugs"""
8973    query: String
8974  ): BugConnection!
8975  bug(prefix: String!): Bug
8976}
8977
8978`},
8979	&ast.Source{Name: "schema/identity.graphql", Input: `"""Represents an identity"""
8980type Identity {
8981    """The name of the person, if known."""
8982    name: String
8983    """The email of the person, if known."""
8984    email: String
8985    """The login of the person, if known."""
8986    login: String
8987    """A string containing the either the name of the person, its login or both"""
8988    displayName: String!
8989    """An url to an avatar"""
8990    avatarUrl: String
8991}`},
8992	&ast.Source{Name: "schema/operations.graphql", Input: `"""An operation applied to a bug."""
8993interface Operation {
8994    """The hash of the operation"""
8995    hash: Hash!
8996    """The operations author."""
8997    author: Identity!
8998    """The datetime when this operation was issued."""
8999    date: Time!
9000}
9001
9002# Connection
9003
9004"""The connection type for an Operation"""
9005type OperationConnection {
9006    edges: [OperationEdge!]!
9007    nodes: [Operation!]!
9008    pageInfo: PageInfo!
9009    totalCount: Int!
9010}
9011
9012"""Represent an Operation"""
9013type OperationEdge {
9014    cursor: String!
9015    node: Operation!
9016}
9017
9018# Operations
9019
9020type CreateOperation implements Operation & Authored {
9021    """The hash of the operation"""
9022    hash: Hash!
9023    """The author of this object."""
9024    author: Identity!
9025    """The datetime when this operation was issued."""
9026    date: Time!
9027
9028    title: String!
9029    message: String!
9030    files: [Hash!]!
9031}
9032
9033type SetTitleOperation implements Operation & Authored {
9034    """The hash of the operation"""
9035    hash: Hash!
9036    """The author of this object."""
9037    author: Identity!
9038    """The datetime when this operation was issued."""
9039    date: Time!
9040
9041    title: String!
9042    was: String!
9043}
9044
9045type AddCommentOperation implements Operation & Authored {
9046    """The hash of the operation"""
9047    hash: Hash!
9048    """The author of this object."""
9049    author: Identity!
9050    """The datetime when this operation was issued."""
9051    date: Time!
9052
9053    message: String!
9054    files: [Hash!]!
9055}
9056
9057type EditCommentOperation implements Operation & Authored {
9058    """The hash of the operation"""
9059    hash: Hash!
9060    """The author of this object."""
9061    author: Identity!
9062    """The datetime when this operation was issued."""
9063    date: Time!
9064
9065    target: Hash!
9066    message: String!
9067    files: [Hash!]!
9068}
9069
9070type SetStatusOperation implements Operation & Authored {
9071    """The hash of the operation"""
9072    hash: Hash!
9073    """The author of this object."""
9074    author: Identity!
9075    """The datetime when this operation was issued."""
9076    date: Time!
9077
9078    status: Status!
9079}
9080
9081type LabelChangeOperation implements Operation & Authored {
9082    """The hash of the operation"""
9083    hash: Hash!
9084    """The author of this object."""
9085    author: Identity!
9086    """The datetime when this operation was issued."""
9087    date: Time!
9088
9089    added: [Label!]!
9090    removed: [Label!]!
9091}`},
9092	&ast.Source{Name: "schema/root.graphql", Input: `scalar Time
9093scalar Label
9094scalar Hash
9095
9096"""Information about pagination in a connection."""
9097type PageInfo {
9098    """When paginating forwards, are there more items?"""
9099    hasNextPage: Boolean!
9100    """When paginating backwards, are there more items?"""
9101    hasPreviousPage: Boolean!
9102    """When paginating backwards, the cursor to continue."""
9103    startCursor: String!
9104    """When paginating forwards, the cursor to continue."""
9105    endCursor: String!
9106}
9107
9108"""An object that has an author."""
9109interface Authored {
9110    """The author of this object."""
9111    author: Identity!
9112}
9113
9114type Query {
9115    defaultRepository: Repository
9116    repository(id: String!): Repository
9117}
9118
9119type Mutation {
9120    newBug(repoRef: String, title: String!, message: String!, files: [Hash!]): Bug!
9121
9122    addComment(repoRef: String, prefix: String!, message: String!, files: [Hash!]): Bug!
9123    changeLabels(repoRef: String, prefix: String!, added: [String!], removed: [String!]): Bug!
9124    open(repoRef: String, prefix: String!): Bug!
9125    close(repoRef: String, prefix: String!): Bug!
9126    setTitle(repoRef: String, prefix: String!, title: String!): Bug!
9127
9128    commit(repoRef: String, prefix: String!): Bug!
9129}`},
9130	&ast.Source{Name: "schema/timeline.graphql", Input: `"""An item in the timeline of events"""
9131interface TimelineItem {
9132    """The hash of the source operation"""
9133    hash: Hash!
9134}
9135
9136"""CommentHistoryStep hold one version of a message in the history"""
9137type CommentHistoryStep {
9138    message: String!
9139    date: Time!
9140}
9141
9142# Connection
9143
9144"""The connection type for TimelineItem"""
9145type TimelineItemConnection {
9146    edges: [TimelineItemEdge!]!
9147    nodes: [TimelineItem!]!
9148    pageInfo: PageInfo!
9149    totalCount: Int!
9150}
9151
9152"""Represent a TimelineItem"""
9153type TimelineItemEdge {
9154    cursor: String!
9155    node: TimelineItem!
9156}
9157
9158# Items
9159
9160"""CreateTimelineItem is a TimelineItem that represent the creation of a bug and its message edition history"""
9161type CreateTimelineItem implements TimelineItem {
9162    """The hash of the source operation"""
9163    hash: Hash!
9164    author: Identity!
9165    message: String!
9166    messageIsEmpty: Boolean!
9167    files: [Hash!]!
9168    createdAt: Time!
9169    lastEdit: Time!
9170    edited: Boolean!
9171    history: [CommentHistoryStep!]!
9172}
9173
9174"""AddCommentTimelineItem is a TimelineItem that represent a Comment and its edition history"""
9175type AddCommentTimelineItem implements TimelineItem {
9176    """The hash of the source operation"""
9177    hash: Hash!
9178    author: Identity!
9179    message: String!
9180    messageIsEmpty: Boolean!
9181    files: [Hash!]!
9182    createdAt: Time!
9183    lastEdit: Time!
9184    edited: Boolean!
9185    history: [CommentHistoryStep!]!
9186}
9187
9188"""LabelChangeTimelineItem is a TimelineItem that represent a change in the labels of a bug"""
9189type LabelChangeTimelineItem implements TimelineItem {
9190    """The hash of the source operation"""
9191    hash: Hash!
9192    author: Identity!
9193    date: Time!
9194    added: [Label!]!
9195    removed: [Label!]!
9196}
9197
9198"""SetStatusTimelineItem is a TimelineItem that represent a change in the status of a bug"""
9199type SetStatusTimelineItem implements TimelineItem {
9200    """The hash of the source operation"""
9201    hash: Hash!
9202    author: Identity!
9203    date: Time!
9204    status: Status!
9205}
9206
9207"""LabelChangeTimelineItem is a TimelineItem that represent a change in the title of a bug"""
9208type SetTitleTimelineItem implements TimelineItem {
9209    """The hash of the source operation"""
9210    hash: Hash!
9211    author: Identity!
9212    date: Time!
9213    title: String!
9214    was: String!
9215}`},
9216)