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