1// Code generated by github.com/99designs/gqlgen, DO NOT EDIT.
   2
   3package graph
   4
   5import (
   6	"bytes"
   7	context "context"
   8	fmt "fmt"
   9	strconv "strconv"
  10	sync "sync"
  11	time "time"
  12
  13	graphql "github.com/99designs/gqlgen/graphql"
  14	introspection "github.com/99designs/gqlgen/graphql/introspection"
  15	bug "github.com/MichaelMure/git-bug/bug"
  16	models "github.com/MichaelMure/git-bug/graphql/models"
  17	operations "github.com/MichaelMure/git-bug/operations"
  18	git "github.com/MichaelMure/git-bug/util/git"
  19	gqlparser "github.com/vektah/gqlparser"
  20	ast "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	Bug() BugResolver
  41	CreateOperation() CreateOperationResolver
  42	LabelChangeOperation() LabelChangeOperationResolver
  43	Mutation() MutationResolver
  44	Query() QueryResolver
  45	Repository() RepositoryResolver
  46	SetStatusOperation() SetStatusOperationResolver
  47	SetTitleOperation() SetTitleOperationResolver
  48}
  49
  50type DirectiveRoot struct {
  51}
  52
  53type ComplexityRoot struct {
  54	AddCommentOperation struct {
  55		Author  func(childComplexity int) int
  56		Date    func(childComplexity int) int
  57		Message func(childComplexity int) int
  58		Files   func(childComplexity int) int
  59	}
  60
  61	Bug struct {
  62		Id         func(childComplexity int) int
  63		HumanId    func(childComplexity int) int
  64		Status     func(childComplexity int) int
  65		Title      func(childComplexity int) int
  66		Labels     func(childComplexity int) int
  67		Author     func(childComplexity int) int
  68		CreatedAt  func(childComplexity int) int
  69		LastEdit   func(childComplexity int) int
  70		Comments   func(childComplexity int, after *string, before *string, first *int, last *int) int
  71		Operations func(childComplexity int, after *string, before *string, first *int, last *int) int
  72	}
  73
  74	BugConnection struct {
  75		Edges      func(childComplexity int) int
  76		Nodes      func(childComplexity int) int
  77		PageInfo   func(childComplexity int) int
  78		TotalCount func(childComplexity int) int
  79	}
  80
  81	BugEdge struct {
  82		Cursor func(childComplexity int) int
  83		Node   func(childComplexity int) int
  84	}
  85
  86	Comment struct {
  87		Author  func(childComplexity int) int
  88		Message func(childComplexity int) int
  89		Files   func(childComplexity int) int
  90	}
  91
  92	CommentConnection struct {
  93		Edges      func(childComplexity int) int
  94		Nodes      func(childComplexity int) int
  95		PageInfo   func(childComplexity int) int
  96		TotalCount func(childComplexity int) int
  97	}
  98
  99	CommentEdge struct {
 100		Cursor func(childComplexity int) int
 101		Node   func(childComplexity int) int
 102	}
 103
 104	CreateOperation struct {
 105		Author  func(childComplexity int) int
 106		Date    func(childComplexity int) int
 107		Title   func(childComplexity int) int
 108		Message func(childComplexity int) int
 109		Files   func(childComplexity int) int
 110	}
 111
 112	LabelChangeOperation struct {
 113		Author  func(childComplexity int) int
 114		Date    func(childComplexity int) int
 115		Added   func(childComplexity int) int
 116		Removed func(childComplexity int) int
 117	}
 118
 119	Mutation struct {
 120		NewBug       func(childComplexity int, repoRef *string, title string, message string, files []git.Hash) int
 121		AddComment   func(childComplexity int, repoRef *string, prefix string, message string, files []git.Hash) int
 122		ChangeLabels func(childComplexity int, repoRef *string, prefix string, added []string, removed []string) int
 123		Open         func(childComplexity int, repoRef *string, prefix string) int
 124		Close        func(childComplexity int, repoRef *string, prefix string) int
 125		SetTitle     func(childComplexity int, repoRef *string, prefix string, title string) int
 126		Commit       func(childComplexity int, repoRef *string, prefix string) int
 127	}
 128
 129	OperationConnection struct {
 130		Edges      func(childComplexity int) int
 131		Nodes      func(childComplexity int) int
 132		PageInfo   func(childComplexity int) int
 133		TotalCount func(childComplexity int) int
 134	}
 135
 136	OperationEdge struct {
 137		Cursor func(childComplexity int) int
 138		Node   func(childComplexity int) int
 139	}
 140
 141	PageInfo struct {
 142		HasNextPage     func(childComplexity int) int
 143		HasPreviousPage func(childComplexity int) int
 144		StartCursor     func(childComplexity int) int
 145		EndCursor       func(childComplexity int) int
 146	}
 147
 148	Person struct {
 149		Email func(childComplexity int) int
 150		Name  func(childComplexity int) int
 151	}
 152
 153	Query struct {
 154		DefaultRepository func(childComplexity int) int
 155		Repository        func(childComplexity int, id string) int
 156	}
 157
 158	Repository struct {
 159		AllBugs func(childComplexity int, after *string, before *string, first *int, last *int, query *string) int
 160		Bug     func(childComplexity int, prefix string) int
 161	}
 162
 163	SetStatusOperation struct {
 164		Author func(childComplexity int) int
 165		Date   func(childComplexity int) int
 166		Status func(childComplexity int) int
 167	}
 168
 169	SetTitleOperation struct {
 170		Author func(childComplexity int) int
 171		Date   func(childComplexity int) int
 172		Title  func(childComplexity int) int
 173		Was    func(childComplexity int) int
 174	}
 175}
 176
 177type AddCommentOperationResolver interface {
 178	Date(ctx context.Context, obj *operations.AddCommentOperation) (time.Time, error)
 179}
 180type BugResolver interface {
 181	Status(ctx context.Context, obj *bug.Snapshot) (models.Status, error)
 182
 183	LastEdit(ctx context.Context, obj *bug.Snapshot) (time.Time, error)
 184	Comments(ctx context.Context, obj *bug.Snapshot, after *string, before *string, first *int, last *int) (models.CommentConnection, error)
 185	Operations(ctx context.Context, obj *bug.Snapshot, after *string, before *string, first *int, last *int) (models.OperationConnection, error)
 186}
 187type CreateOperationResolver interface {
 188	Date(ctx context.Context, obj *operations.CreateOperation) (time.Time, error)
 189}
 190type LabelChangeOperationResolver interface {
 191	Date(ctx context.Context, obj *operations.LabelChangeOperation) (time.Time, error)
 192}
 193type MutationResolver interface {
 194	NewBug(ctx context.Context, repoRef *string, title string, message string, files []git.Hash) (bug.Snapshot, error)
 195	AddComment(ctx context.Context, repoRef *string, prefix string, message string, files []git.Hash) (bug.Snapshot, error)
 196	ChangeLabels(ctx context.Context, repoRef *string, prefix string, added []string, removed []string) (bug.Snapshot, error)
 197	Open(ctx context.Context, repoRef *string, prefix string) (bug.Snapshot, error)
 198	Close(ctx context.Context, repoRef *string, prefix string) (bug.Snapshot, error)
 199	SetTitle(ctx context.Context, repoRef *string, prefix string, title string) (bug.Snapshot, error)
 200	Commit(ctx context.Context, repoRef *string, prefix string) (bug.Snapshot, error)
 201}
 202type QueryResolver interface {
 203	DefaultRepository(ctx context.Context) (*models.Repository, error)
 204	Repository(ctx context.Context, id string) (*models.Repository, error)
 205}
 206type RepositoryResolver interface {
 207	AllBugs(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int, query *string) (models.BugConnection, error)
 208	Bug(ctx context.Context, obj *models.Repository, prefix string) (*bug.Snapshot, error)
 209}
 210type SetStatusOperationResolver interface {
 211	Date(ctx context.Context, obj *operations.SetStatusOperation) (time.Time, error)
 212	Status(ctx context.Context, obj *operations.SetStatusOperation) (models.Status, error)
 213}
 214type SetTitleOperationResolver interface {
 215	Date(ctx context.Context, obj *operations.SetTitleOperation) (time.Time, error)
 216}
 217
 218func field_Bug_comments_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
 219	args := map[string]interface{}{}
 220	var arg0 *string
 221	if tmp, ok := rawArgs["after"]; ok {
 222		var err error
 223		var ptr1 string
 224		if tmp != nil {
 225			ptr1, err = graphql.UnmarshalString(tmp)
 226			arg0 = &ptr1
 227		}
 228
 229		if err != nil {
 230			return nil, err
 231		}
 232	}
 233	args["after"] = arg0
 234	var arg1 *string
 235	if tmp, ok := rawArgs["before"]; ok {
 236		var err error
 237		var ptr1 string
 238		if tmp != nil {
 239			ptr1, err = graphql.UnmarshalString(tmp)
 240			arg1 = &ptr1
 241		}
 242
 243		if err != nil {
 244			return nil, err
 245		}
 246	}
 247	args["before"] = arg1
 248	var arg2 *int
 249	if tmp, ok := rawArgs["first"]; ok {
 250		var err error
 251		var ptr1 int
 252		if tmp != nil {
 253			ptr1, err = graphql.UnmarshalInt(tmp)
 254			arg2 = &ptr1
 255		}
 256
 257		if err != nil {
 258			return nil, err
 259		}
 260	}
 261	args["first"] = arg2
 262	var arg3 *int
 263	if tmp, ok := rawArgs["last"]; ok {
 264		var err error
 265		var ptr1 int
 266		if tmp != nil {
 267			ptr1, err = graphql.UnmarshalInt(tmp)
 268			arg3 = &ptr1
 269		}
 270
 271		if err != nil {
 272			return nil, err
 273		}
 274	}
 275	args["last"] = arg3
 276	return args, nil
 277
 278}
 279
 280func field_Bug_operations_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
 281	args := map[string]interface{}{}
 282	var arg0 *string
 283	if tmp, ok := rawArgs["after"]; ok {
 284		var err error
 285		var ptr1 string
 286		if tmp != nil {
 287			ptr1, err = graphql.UnmarshalString(tmp)
 288			arg0 = &ptr1
 289		}
 290
 291		if err != nil {
 292			return nil, err
 293		}
 294	}
 295	args["after"] = arg0
 296	var arg1 *string
 297	if tmp, ok := rawArgs["before"]; ok {
 298		var err error
 299		var ptr1 string
 300		if tmp != nil {
 301			ptr1, err = graphql.UnmarshalString(tmp)
 302			arg1 = &ptr1
 303		}
 304
 305		if err != nil {
 306			return nil, err
 307		}
 308	}
 309	args["before"] = arg1
 310	var arg2 *int
 311	if tmp, ok := rawArgs["first"]; ok {
 312		var err error
 313		var ptr1 int
 314		if tmp != nil {
 315			ptr1, err = graphql.UnmarshalInt(tmp)
 316			arg2 = &ptr1
 317		}
 318
 319		if err != nil {
 320			return nil, err
 321		}
 322	}
 323	args["first"] = arg2
 324	var arg3 *int
 325	if tmp, ok := rawArgs["last"]; ok {
 326		var err error
 327		var ptr1 int
 328		if tmp != nil {
 329			ptr1, err = graphql.UnmarshalInt(tmp)
 330			arg3 = &ptr1
 331		}
 332
 333		if err != nil {
 334			return nil, err
 335		}
 336	}
 337	args["last"] = arg3
 338	return args, nil
 339
 340}
 341
 342func field_Mutation_newBug_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
 343	args := map[string]interface{}{}
 344	var arg0 *string
 345	if tmp, ok := rawArgs["repoRef"]; ok {
 346		var err error
 347		var ptr1 string
 348		if tmp != nil {
 349			ptr1, err = graphql.UnmarshalString(tmp)
 350			arg0 = &ptr1
 351		}
 352
 353		if err != nil {
 354			return nil, err
 355		}
 356	}
 357	args["repoRef"] = arg0
 358	var arg1 string
 359	if tmp, ok := rawArgs["title"]; ok {
 360		var err error
 361		arg1, err = graphql.UnmarshalString(tmp)
 362		if err != nil {
 363			return nil, err
 364		}
 365	}
 366	args["title"] = arg1
 367	var arg2 string
 368	if tmp, ok := rawArgs["message"]; ok {
 369		var err error
 370		arg2, err = graphql.UnmarshalString(tmp)
 371		if err != nil {
 372			return nil, err
 373		}
 374	}
 375	args["message"] = arg2
 376	var arg3 []git.Hash
 377	if tmp, ok := rawArgs["files"]; ok {
 378		var err error
 379		var rawIf1 []interface{}
 380		if tmp != nil {
 381			if tmp1, ok := tmp.([]interface{}); ok {
 382				rawIf1 = tmp1
 383			} else {
 384				rawIf1 = []interface{}{tmp}
 385			}
 386		}
 387		arg3 = make([]git.Hash, len(rawIf1))
 388		for idx1 := range rawIf1 {
 389			err = (&arg3[idx1]).UnmarshalGQL(rawIf1[idx1])
 390		}
 391		if err != nil {
 392			return nil, err
 393		}
 394	}
 395	args["files"] = arg3
 396	return args, nil
 397
 398}
 399
 400func field_Mutation_addComment_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
 401	args := map[string]interface{}{}
 402	var arg0 *string
 403	if tmp, ok := rawArgs["repoRef"]; 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["repoRef"] = arg0
 416	var arg1 string
 417	if tmp, ok := rawArgs["prefix"]; ok {
 418		var err error
 419		arg1, err = graphql.UnmarshalString(tmp)
 420		if err != nil {
 421			return nil, err
 422		}
 423	}
 424	args["prefix"] = arg1
 425	var arg2 string
 426	if tmp, ok := rawArgs["message"]; ok {
 427		var err error
 428		arg2, err = graphql.UnmarshalString(tmp)
 429		if err != nil {
 430			return nil, err
 431		}
 432	}
 433	args["message"] = arg2
 434	var arg3 []git.Hash
 435	if tmp, ok := rawArgs["files"]; ok {
 436		var err error
 437		var rawIf1 []interface{}
 438		if tmp != nil {
 439			if tmp1, ok := tmp.([]interface{}); ok {
 440				rawIf1 = tmp1
 441			} else {
 442				rawIf1 = []interface{}{tmp}
 443			}
 444		}
 445		arg3 = make([]git.Hash, len(rawIf1))
 446		for idx1 := range rawIf1 {
 447			err = (&arg3[idx1]).UnmarshalGQL(rawIf1[idx1])
 448		}
 449		if err != nil {
 450			return nil, err
 451		}
 452	}
 453	args["files"] = arg3
 454	return args, nil
 455
 456}
 457
 458func field_Mutation_changeLabels_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
 459	args := map[string]interface{}{}
 460	var arg0 *string
 461	if tmp, ok := rawArgs["repoRef"]; ok {
 462		var err error
 463		var ptr1 string
 464		if tmp != nil {
 465			ptr1, err = graphql.UnmarshalString(tmp)
 466			arg0 = &ptr1
 467		}
 468
 469		if err != nil {
 470			return nil, err
 471		}
 472	}
 473	args["repoRef"] = arg0
 474	var arg1 string
 475	if tmp, ok := rawArgs["prefix"]; ok {
 476		var err error
 477		arg1, err = graphql.UnmarshalString(tmp)
 478		if err != nil {
 479			return nil, err
 480		}
 481	}
 482	args["prefix"] = arg1
 483	var arg2 []string
 484	if tmp, ok := rawArgs["added"]; ok {
 485		var err error
 486		var rawIf1 []interface{}
 487		if tmp != nil {
 488			if tmp1, ok := tmp.([]interface{}); ok {
 489				rawIf1 = tmp1
 490			} else {
 491				rawIf1 = []interface{}{tmp}
 492			}
 493		}
 494		arg2 = make([]string, len(rawIf1))
 495		for idx1 := range rawIf1 {
 496			arg2[idx1], err = graphql.UnmarshalString(rawIf1[idx1])
 497		}
 498		if err != nil {
 499			return nil, err
 500		}
 501	}
 502	args["added"] = arg2
 503	var arg3 []string
 504	if tmp, ok := rawArgs["removed"]; ok {
 505		var err error
 506		var rawIf1 []interface{}
 507		if tmp != nil {
 508			if tmp1, ok := tmp.([]interface{}); ok {
 509				rawIf1 = tmp1
 510			} else {
 511				rawIf1 = []interface{}{tmp}
 512			}
 513		}
 514		arg3 = make([]string, len(rawIf1))
 515		for idx1 := range rawIf1 {
 516			arg3[idx1], err = graphql.UnmarshalString(rawIf1[idx1])
 517		}
 518		if err != nil {
 519			return nil, err
 520		}
 521	}
 522	args["removed"] = arg3
 523	return args, nil
 524
 525}
 526
 527func field_Mutation_open_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
 528	args := map[string]interface{}{}
 529	var arg0 *string
 530	if tmp, ok := rawArgs["repoRef"]; ok {
 531		var err error
 532		var ptr1 string
 533		if tmp != nil {
 534			ptr1, err = graphql.UnmarshalString(tmp)
 535			arg0 = &ptr1
 536		}
 537
 538		if err != nil {
 539			return nil, err
 540		}
 541	}
 542	args["repoRef"] = arg0
 543	var arg1 string
 544	if tmp, ok := rawArgs["prefix"]; ok {
 545		var err error
 546		arg1, err = graphql.UnmarshalString(tmp)
 547		if err != nil {
 548			return nil, err
 549		}
 550	}
 551	args["prefix"] = arg1
 552	return args, nil
 553
 554}
 555
 556func field_Mutation_close_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
 557	args := map[string]interface{}{}
 558	var arg0 *string
 559	if tmp, ok := rawArgs["repoRef"]; ok {
 560		var err error
 561		var ptr1 string
 562		if tmp != nil {
 563			ptr1, err = graphql.UnmarshalString(tmp)
 564			arg0 = &ptr1
 565		}
 566
 567		if err != nil {
 568			return nil, err
 569		}
 570	}
 571	args["repoRef"] = arg0
 572	var arg1 string
 573	if tmp, ok := rawArgs["prefix"]; ok {
 574		var err error
 575		arg1, err = graphql.UnmarshalString(tmp)
 576		if err != nil {
 577			return nil, err
 578		}
 579	}
 580	args["prefix"] = arg1
 581	return args, nil
 582
 583}
 584
 585func field_Mutation_setTitle_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
 586	args := map[string]interface{}{}
 587	var arg0 *string
 588	if tmp, ok := rawArgs["repoRef"]; ok {
 589		var err error
 590		var ptr1 string
 591		if tmp != nil {
 592			ptr1, err = graphql.UnmarshalString(tmp)
 593			arg0 = &ptr1
 594		}
 595
 596		if err != nil {
 597			return nil, err
 598		}
 599	}
 600	args["repoRef"] = arg0
 601	var arg1 string
 602	if tmp, ok := rawArgs["prefix"]; ok {
 603		var err error
 604		arg1, err = graphql.UnmarshalString(tmp)
 605		if err != nil {
 606			return nil, err
 607		}
 608	}
 609	args["prefix"] = arg1
 610	var arg2 string
 611	if tmp, ok := rawArgs["title"]; ok {
 612		var err error
 613		arg2, err = graphql.UnmarshalString(tmp)
 614		if err != nil {
 615			return nil, err
 616		}
 617	}
 618	args["title"] = arg2
 619	return args, nil
 620
 621}
 622
 623func field_Mutation_commit_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
 624	args := map[string]interface{}{}
 625	var arg0 *string
 626	if tmp, ok := rawArgs["repoRef"]; ok {
 627		var err error
 628		var ptr1 string
 629		if tmp != nil {
 630			ptr1, err = graphql.UnmarshalString(tmp)
 631			arg0 = &ptr1
 632		}
 633
 634		if err != nil {
 635			return nil, err
 636		}
 637	}
 638	args["repoRef"] = arg0
 639	var arg1 string
 640	if tmp, ok := rawArgs["prefix"]; ok {
 641		var err error
 642		arg1, err = graphql.UnmarshalString(tmp)
 643		if err != nil {
 644			return nil, err
 645		}
 646	}
 647	args["prefix"] = arg1
 648	return args, nil
 649
 650}
 651
 652func field_Query_repository_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
 653	args := map[string]interface{}{}
 654	var arg0 string
 655	if tmp, ok := rawArgs["id"]; ok {
 656		var err error
 657		arg0, err = graphql.UnmarshalString(tmp)
 658		if err != nil {
 659			return nil, err
 660		}
 661	}
 662	args["id"] = arg0
 663	return args, nil
 664
 665}
 666
 667func field_Query___type_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
 668	args := map[string]interface{}{}
 669	var arg0 string
 670	if tmp, ok := rawArgs["name"]; ok {
 671		var err error
 672		arg0, err = graphql.UnmarshalString(tmp)
 673		if err != nil {
 674			return nil, err
 675		}
 676	}
 677	args["name"] = arg0
 678	return args, nil
 679
 680}
 681
 682func field_Repository_allBugs_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
 683	args := map[string]interface{}{}
 684	var arg0 *string
 685	if tmp, ok := rawArgs["after"]; ok {
 686		var err error
 687		var ptr1 string
 688		if tmp != nil {
 689			ptr1, err = graphql.UnmarshalString(tmp)
 690			arg0 = &ptr1
 691		}
 692
 693		if err != nil {
 694			return nil, err
 695		}
 696	}
 697	args["after"] = arg0
 698	var arg1 *string
 699	if tmp, ok := rawArgs["before"]; ok {
 700		var err error
 701		var ptr1 string
 702		if tmp != nil {
 703			ptr1, err = graphql.UnmarshalString(tmp)
 704			arg1 = &ptr1
 705		}
 706
 707		if err != nil {
 708			return nil, err
 709		}
 710	}
 711	args["before"] = arg1
 712	var arg2 *int
 713	if tmp, ok := rawArgs["first"]; ok {
 714		var err error
 715		var ptr1 int
 716		if tmp != nil {
 717			ptr1, err = graphql.UnmarshalInt(tmp)
 718			arg2 = &ptr1
 719		}
 720
 721		if err != nil {
 722			return nil, err
 723		}
 724	}
 725	args["first"] = arg2
 726	var arg3 *int
 727	if tmp, ok := rawArgs["last"]; ok {
 728		var err error
 729		var ptr1 int
 730		if tmp != nil {
 731			ptr1, err = graphql.UnmarshalInt(tmp)
 732			arg3 = &ptr1
 733		}
 734
 735		if err != nil {
 736			return nil, err
 737		}
 738	}
 739	args["last"] = arg3
 740	var arg4 *string
 741	if tmp, ok := rawArgs["query"]; ok {
 742		var err error
 743		var ptr1 string
 744		if tmp != nil {
 745			ptr1, err = graphql.UnmarshalString(tmp)
 746			arg4 = &ptr1
 747		}
 748
 749		if err != nil {
 750			return nil, err
 751		}
 752	}
 753	args["query"] = arg4
 754	return args, nil
 755
 756}
 757
 758func field_Repository_bug_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
 759	args := map[string]interface{}{}
 760	var arg0 string
 761	if tmp, ok := rawArgs["prefix"]; ok {
 762		var err error
 763		arg0, err = graphql.UnmarshalString(tmp)
 764		if err != nil {
 765			return nil, err
 766		}
 767	}
 768	args["prefix"] = arg0
 769	return args, nil
 770
 771}
 772
 773func field___Type_fields_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
 774	args := map[string]interface{}{}
 775	var arg0 bool
 776	if tmp, ok := rawArgs["includeDeprecated"]; ok {
 777		var err error
 778		arg0, err = graphql.UnmarshalBoolean(tmp)
 779		if err != nil {
 780			return nil, err
 781		}
 782	}
 783	args["includeDeprecated"] = arg0
 784	return args, nil
 785
 786}
 787
 788func field___Type_enumValues_args(rawArgs map[string]interface{}) (map[string]interface{}, error) {
 789	args := map[string]interface{}{}
 790	var arg0 bool
 791	if tmp, ok := rawArgs["includeDeprecated"]; ok {
 792		var err error
 793		arg0, err = graphql.UnmarshalBoolean(tmp)
 794		if err != nil {
 795			return nil, err
 796		}
 797	}
 798	args["includeDeprecated"] = arg0
 799	return args, nil
 800
 801}
 802
 803type executableSchema struct {
 804	resolvers  ResolverRoot
 805	directives DirectiveRoot
 806	complexity ComplexityRoot
 807}
 808
 809func (e *executableSchema) Schema() *ast.Schema {
 810	return parsedSchema
 811}
 812
 813func (e *executableSchema) Complexity(typeName, field string, childComplexity int, rawArgs map[string]interface{}) (int, bool) {
 814	switch typeName + "." + field {
 815
 816	case "AddCommentOperation.author":
 817		if e.complexity.AddCommentOperation.Author == nil {
 818			break
 819		}
 820
 821		return e.complexity.AddCommentOperation.Author(childComplexity), true
 822
 823	case "AddCommentOperation.date":
 824		if e.complexity.AddCommentOperation.Date == nil {
 825			break
 826		}
 827
 828		return e.complexity.AddCommentOperation.Date(childComplexity), true
 829
 830	case "AddCommentOperation.message":
 831		if e.complexity.AddCommentOperation.Message == nil {
 832			break
 833		}
 834
 835		return e.complexity.AddCommentOperation.Message(childComplexity), true
 836
 837	case "AddCommentOperation.files":
 838		if e.complexity.AddCommentOperation.Files == nil {
 839			break
 840		}
 841
 842		return e.complexity.AddCommentOperation.Files(childComplexity), true
 843
 844	case "Bug.id":
 845		if e.complexity.Bug.Id == nil {
 846			break
 847		}
 848
 849		return e.complexity.Bug.Id(childComplexity), true
 850
 851	case "Bug.humanId":
 852		if e.complexity.Bug.HumanId == nil {
 853			break
 854		}
 855
 856		return e.complexity.Bug.HumanId(childComplexity), true
 857
 858	case "Bug.status":
 859		if e.complexity.Bug.Status == nil {
 860			break
 861		}
 862
 863		return e.complexity.Bug.Status(childComplexity), true
 864
 865	case "Bug.title":
 866		if e.complexity.Bug.Title == nil {
 867			break
 868		}
 869
 870		return e.complexity.Bug.Title(childComplexity), true
 871
 872	case "Bug.labels":
 873		if e.complexity.Bug.Labels == nil {
 874			break
 875		}
 876
 877		return e.complexity.Bug.Labels(childComplexity), true
 878
 879	case "Bug.author":
 880		if e.complexity.Bug.Author == nil {
 881			break
 882		}
 883
 884		return e.complexity.Bug.Author(childComplexity), true
 885
 886	case "Bug.createdAt":
 887		if e.complexity.Bug.CreatedAt == nil {
 888			break
 889		}
 890
 891		return e.complexity.Bug.CreatedAt(childComplexity), true
 892
 893	case "Bug.lastEdit":
 894		if e.complexity.Bug.LastEdit == nil {
 895			break
 896		}
 897
 898		return e.complexity.Bug.LastEdit(childComplexity), true
 899
 900	case "Bug.comments":
 901		if e.complexity.Bug.Comments == nil {
 902			break
 903		}
 904
 905		args, err := field_Bug_comments_args(rawArgs)
 906		if err != nil {
 907			return 0, false
 908		}
 909
 910		return e.complexity.Bug.Comments(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
 911
 912	case "Bug.operations":
 913		if e.complexity.Bug.Operations == nil {
 914			break
 915		}
 916
 917		args, err := field_Bug_operations_args(rawArgs)
 918		if err != nil {
 919			return 0, false
 920		}
 921
 922		return e.complexity.Bug.Operations(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
 923
 924	case "BugConnection.edges":
 925		if e.complexity.BugConnection.Edges == nil {
 926			break
 927		}
 928
 929		return e.complexity.BugConnection.Edges(childComplexity), true
 930
 931	case "BugConnection.nodes":
 932		if e.complexity.BugConnection.Nodes == nil {
 933			break
 934		}
 935
 936		return e.complexity.BugConnection.Nodes(childComplexity), true
 937
 938	case "BugConnection.pageInfo":
 939		if e.complexity.BugConnection.PageInfo == nil {
 940			break
 941		}
 942
 943		return e.complexity.BugConnection.PageInfo(childComplexity), true
 944
 945	case "BugConnection.totalCount":
 946		if e.complexity.BugConnection.TotalCount == nil {
 947			break
 948		}
 949
 950		return e.complexity.BugConnection.TotalCount(childComplexity), true
 951
 952	case "BugEdge.cursor":
 953		if e.complexity.BugEdge.Cursor == nil {
 954			break
 955		}
 956
 957		return e.complexity.BugEdge.Cursor(childComplexity), true
 958
 959	case "BugEdge.node":
 960		if e.complexity.BugEdge.Node == nil {
 961			break
 962		}
 963
 964		return e.complexity.BugEdge.Node(childComplexity), true
 965
 966	case "Comment.author":
 967		if e.complexity.Comment.Author == nil {
 968			break
 969		}
 970
 971		return e.complexity.Comment.Author(childComplexity), true
 972
 973	case "Comment.message":
 974		if e.complexity.Comment.Message == nil {
 975			break
 976		}
 977
 978		return e.complexity.Comment.Message(childComplexity), true
 979
 980	case "Comment.files":
 981		if e.complexity.Comment.Files == nil {
 982			break
 983		}
 984
 985		return e.complexity.Comment.Files(childComplexity), true
 986
 987	case "CommentConnection.edges":
 988		if e.complexity.CommentConnection.Edges == nil {
 989			break
 990		}
 991
 992		return e.complexity.CommentConnection.Edges(childComplexity), true
 993
 994	case "CommentConnection.nodes":
 995		if e.complexity.CommentConnection.Nodes == nil {
 996			break
 997		}
 998
 999		return e.complexity.CommentConnection.Nodes(childComplexity), true
1000
1001	case "CommentConnection.pageInfo":
1002		if e.complexity.CommentConnection.PageInfo == nil {
1003			break
1004		}
1005
1006		return e.complexity.CommentConnection.PageInfo(childComplexity), true
1007
1008	case "CommentConnection.totalCount":
1009		if e.complexity.CommentConnection.TotalCount == nil {
1010			break
1011		}
1012
1013		return e.complexity.CommentConnection.TotalCount(childComplexity), true
1014
1015	case "CommentEdge.cursor":
1016		if e.complexity.CommentEdge.Cursor == nil {
1017			break
1018		}
1019
1020		return e.complexity.CommentEdge.Cursor(childComplexity), true
1021
1022	case "CommentEdge.node":
1023		if e.complexity.CommentEdge.Node == nil {
1024			break
1025		}
1026
1027		return e.complexity.CommentEdge.Node(childComplexity), true
1028
1029	case "CreateOperation.author":
1030		if e.complexity.CreateOperation.Author == nil {
1031			break
1032		}
1033
1034		return e.complexity.CreateOperation.Author(childComplexity), true
1035
1036	case "CreateOperation.date":
1037		if e.complexity.CreateOperation.Date == nil {
1038			break
1039		}
1040
1041		return e.complexity.CreateOperation.Date(childComplexity), true
1042
1043	case "CreateOperation.title":
1044		if e.complexity.CreateOperation.Title == nil {
1045			break
1046		}
1047
1048		return e.complexity.CreateOperation.Title(childComplexity), true
1049
1050	case "CreateOperation.message":
1051		if e.complexity.CreateOperation.Message == nil {
1052			break
1053		}
1054
1055		return e.complexity.CreateOperation.Message(childComplexity), true
1056
1057	case "CreateOperation.files":
1058		if e.complexity.CreateOperation.Files == nil {
1059			break
1060		}
1061
1062		return e.complexity.CreateOperation.Files(childComplexity), true
1063
1064	case "LabelChangeOperation.author":
1065		if e.complexity.LabelChangeOperation.Author == nil {
1066			break
1067		}
1068
1069		return e.complexity.LabelChangeOperation.Author(childComplexity), true
1070
1071	case "LabelChangeOperation.date":
1072		if e.complexity.LabelChangeOperation.Date == nil {
1073			break
1074		}
1075
1076		return e.complexity.LabelChangeOperation.Date(childComplexity), true
1077
1078	case "LabelChangeOperation.added":
1079		if e.complexity.LabelChangeOperation.Added == nil {
1080			break
1081		}
1082
1083		return e.complexity.LabelChangeOperation.Added(childComplexity), true
1084
1085	case "LabelChangeOperation.removed":
1086		if e.complexity.LabelChangeOperation.Removed == nil {
1087			break
1088		}
1089
1090		return e.complexity.LabelChangeOperation.Removed(childComplexity), true
1091
1092	case "Mutation.newBug":
1093		if e.complexity.Mutation.NewBug == nil {
1094			break
1095		}
1096
1097		args, err := field_Mutation_newBug_args(rawArgs)
1098		if err != nil {
1099			return 0, false
1100		}
1101
1102		return e.complexity.Mutation.NewBug(childComplexity, args["repoRef"].(*string), args["title"].(string), args["message"].(string), args["files"].([]git.Hash)), true
1103
1104	case "Mutation.addComment":
1105		if e.complexity.Mutation.AddComment == nil {
1106			break
1107		}
1108
1109		args, err := field_Mutation_addComment_args(rawArgs)
1110		if err != nil {
1111			return 0, false
1112		}
1113
1114		return e.complexity.Mutation.AddComment(childComplexity, args["repoRef"].(*string), args["prefix"].(string), args["message"].(string), args["files"].([]git.Hash)), true
1115
1116	case "Mutation.changeLabels":
1117		if e.complexity.Mutation.ChangeLabels == nil {
1118			break
1119		}
1120
1121		args, err := field_Mutation_changeLabels_args(rawArgs)
1122		if err != nil {
1123			return 0, false
1124		}
1125
1126		return e.complexity.Mutation.ChangeLabels(childComplexity, args["repoRef"].(*string), args["prefix"].(string), args["added"].([]string), args["removed"].([]string)), true
1127
1128	case "Mutation.open":
1129		if e.complexity.Mutation.Open == nil {
1130			break
1131		}
1132
1133		args, err := field_Mutation_open_args(rawArgs)
1134		if err != nil {
1135			return 0, false
1136		}
1137
1138		return e.complexity.Mutation.Open(childComplexity, args["repoRef"].(*string), args["prefix"].(string)), true
1139
1140	case "Mutation.close":
1141		if e.complexity.Mutation.Close == nil {
1142			break
1143		}
1144
1145		args, err := field_Mutation_close_args(rawArgs)
1146		if err != nil {
1147			return 0, false
1148		}
1149
1150		return e.complexity.Mutation.Close(childComplexity, args["repoRef"].(*string), args["prefix"].(string)), true
1151
1152	case "Mutation.setTitle":
1153		if e.complexity.Mutation.SetTitle == nil {
1154			break
1155		}
1156
1157		args, err := field_Mutation_setTitle_args(rawArgs)
1158		if err != nil {
1159			return 0, false
1160		}
1161
1162		return e.complexity.Mutation.SetTitle(childComplexity, args["repoRef"].(*string), args["prefix"].(string), args["title"].(string)), true
1163
1164	case "Mutation.commit":
1165		if e.complexity.Mutation.Commit == nil {
1166			break
1167		}
1168
1169		args, err := field_Mutation_commit_args(rawArgs)
1170		if err != nil {
1171			return 0, false
1172		}
1173
1174		return e.complexity.Mutation.Commit(childComplexity, args["repoRef"].(*string), args["prefix"].(string)), true
1175
1176	case "OperationConnection.edges":
1177		if e.complexity.OperationConnection.Edges == nil {
1178			break
1179		}
1180
1181		return e.complexity.OperationConnection.Edges(childComplexity), true
1182
1183	case "OperationConnection.nodes":
1184		if e.complexity.OperationConnection.Nodes == nil {
1185			break
1186		}
1187
1188		return e.complexity.OperationConnection.Nodes(childComplexity), true
1189
1190	case "OperationConnection.pageInfo":
1191		if e.complexity.OperationConnection.PageInfo == nil {
1192			break
1193		}
1194
1195		return e.complexity.OperationConnection.PageInfo(childComplexity), true
1196
1197	case "OperationConnection.totalCount":
1198		if e.complexity.OperationConnection.TotalCount == nil {
1199			break
1200		}
1201
1202		return e.complexity.OperationConnection.TotalCount(childComplexity), true
1203
1204	case "OperationEdge.cursor":
1205		if e.complexity.OperationEdge.Cursor == nil {
1206			break
1207		}
1208
1209		return e.complexity.OperationEdge.Cursor(childComplexity), true
1210
1211	case "OperationEdge.node":
1212		if e.complexity.OperationEdge.Node == nil {
1213			break
1214		}
1215
1216		return e.complexity.OperationEdge.Node(childComplexity), true
1217
1218	case "PageInfo.hasNextPage":
1219		if e.complexity.PageInfo.HasNextPage == nil {
1220			break
1221		}
1222
1223		return e.complexity.PageInfo.HasNextPage(childComplexity), true
1224
1225	case "PageInfo.hasPreviousPage":
1226		if e.complexity.PageInfo.HasPreviousPage == nil {
1227			break
1228		}
1229
1230		return e.complexity.PageInfo.HasPreviousPage(childComplexity), true
1231
1232	case "PageInfo.startCursor":
1233		if e.complexity.PageInfo.StartCursor == nil {
1234			break
1235		}
1236
1237		return e.complexity.PageInfo.StartCursor(childComplexity), true
1238
1239	case "PageInfo.endCursor":
1240		if e.complexity.PageInfo.EndCursor == nil {
1241			break
1242		}
1243
1244		return e.complexity.PageInfo.EndCursor(childComplexity), true
1245
1246	case "Person.email":
1247		if e.complexity.Person.Email == nil {
1248			break
1249		}
1250
1251		return e.complexity.Person.Email(childComplexity), true
1252
1253	case "Person.name":
1254		if e.complexity.Person.Name == nil {
1255			break
1256		}
1257
1258		return e.complexity.Person.Name(childComplexity), true
1259
1260	case "Query.defaultRepository":
1261		if e.complexity.Query.DefaultRepository == nil {
1262			break
1263		}
1264
1265		return e.complexity.Query.DefaultRepository(childComplexity), true
1266
1267	case "Query.repository":
1268		if e.complexity.Query.Repository == nil {
1269			break
1270		}
1271
1272		args, err := field_Query_repository_args(rawArgs)
1273		if err != nil {
1274			return 0, false
1275		}
1276
1277		return e.complexity.Query.Repository(childComplexity, args["id"].(string)), true
1278
1279	case "Repository.allBugs":
1280		if e.complexity.Repository.AllBugs == nil {
1281			break
1282		}
1283
1284		args, err := field_Repository_allBugs_args(rawArgs)
1285		if err != nil {
1286			return 0, false
1287		}
1288
1289		return e.complexity.Repository.AllBugs(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int), args["query"].(*string)), true
1290
1291	case "Repository.bug":
1292		if e.complexity.Repository.Bug == nil {
1293			break
1294		}
1295
1296		args, err := field_Repository_bug_args(rawArgs)
1297		if err != nil {
1298			return 0, false
1299		}
1300
1301		return e.complexity.Repository.Bug(childComplexity, args["prefix"].(string)), true
1302
1303	case "SetStatusOperation.author":
1304		if e.complexity.SetStatusOperation.Author == nil {
1305			break
1306		}
1307
1308		return e.complexity.SetStatusOperation.Author(childComplexity), true
1309
1310	case "SetStatusOperation.date":
1311		if e.complexity.SetStatusOperation.Date == nil {
1312			break
1313		}
1314
1315		return e.complexity.SetStatusOperation.Date(childComplexity), true
1316
1317	case "SetStatusOperation.status":
1318		if e.complexity.SetStatusOperation.Status == nil {
1319			break
1320		}
1321
1322		return e.complexity.SetStatusOperation.Status(childComplexity), true
1323
1324	case "SetTitleOperation.author":
1325		if e.complexity.SetTitleOperation.Author == nil {
1326			break
1327		}
1328
1329		return e.complexity.SetTitleOperation.Author(childComplexity), true
1330
1331	case "SetTitleOperation.date":
1332		if e.complexity.SetTitleOperation.Date == nil {
1333			break
1334		}
1335
1336		return e.complexity.SetTitleOperation.Date(childComplexity), true
1337
1338	case "SetTitleOperation.title":
1339		if e.complexity.SetTitleOperation.Title == nil {
1340			break
1341		}
1342
1343		return e.complexity.SetTitleOperation.Title(childComplexity), true
1344
1345	case "SetTitleOperation.was":
1346		if e.complexity.SetTitleOperation.Was == nil {
1347			break
1348		}
1349
1350		return e.complexity.SetTitleOperation.Was(childComplexity), true
1351
1352	}
1353	return 0, false
1354}
1355
1356func (e *executableSchema) Query(ctx context.Context, op *ast.OperationDefinition) *graphql.Response {
1357	ec := executionContext{graphql.GetRequestContext(ctx), e}
1358
1359	buf := ec.RequestMiddleware(ctx, func(ctx context.Context) []byte {
1360		data := ec._Query(ctx, op.SelectionSet)
1361		var buf bytes.Buffer
1362		data.MarshalGQL(&buf)
1363		return buf.Bytes()
1364	})
1365
1366	return &graphql.Response{
1367		Data:   buf,
1368		Errors: ec.Errors,
1369	}
1370}
1371
1372func (e *executableSchema) Mutation(ctx context.Context, op *ast.OperationDefinition) *graphql.Response {
1373	ec := executionContext{graphql.GetRequestContext(ctx), e}
1374
1375	buf := ec.RequestMiddleware(ctx, func(ctx context.Context) []byte {
1376		data := ec._Mutation(ctx, op.SelectionSet)
1377		var buf bytes.Buffer
1378		data.MarshalGQL(&buf)
1379		return buf.Bytes()
1380	})
1381
1382	return &graphql.Response{
1383		Data:   buf,
1384		Errors: ec.Errors,
1385	}
1386}
1387
1388func (e *executableSchema) Subscription(ctx context.Context, op *ast.OperationDefinition) func() *graphql.Response {
1389	return graphql.OneShot(graphql.ErrorResponse(ctx, "subscriptions are not supported"))
1390}
1391
1392type executionContext struct {
1393	*graphql.RequestContext
1394	*executableSchema
1395}
1396
1397var addCommentOperationImplementors = []string{"AddCommentOperation", "Operation", "Authored"}
1398
1399// nolint: gocyclo, errcheck, gas, goconst
1400func (ec *executionContext) _AddCommentOperation(ctx context.Context, sel ast.SelectionSet, obj *operations.AddCommentOperation) graphql.Marshaler {
1401	fields := graphql.CollectFields(ctx, sel, addCommentOperationImplementors)
1402
1403	var wg sync.WaitGroup
1404	out := graphql.NewOrderedMap(len(fields))
1405	invalid := false
1406	for i, field := range fields {
1407		out.Keys[i] = field.Alias
1408
1409		switch field.Name {
1410		case "__typename":
1411			out.Values[i] = graphql.MarshalString("AddCommentOperation")
1412		case "author":
1413			out.Values[i] = ec._AddCommentOperation_author(ctx, field, obj)
1414			if out.Values[i] == graphql.Null {
1415				invalid = true
1416			}
1417		case "date":
1418			wg.Add(1)
1419			go func(i int, field graphql.CollectedField) {
1420				out.Values[i] = ec._AddCommentOperation_date(ctx, field, obj)
1421				if out.Values[i] == graphql.Null {
1422					invalid = true
1423				}
1424				wg.Done()
1425			}(i, field)
1426		case "message":
1427			out.Values[i] = ec._AddCommentOperation_message(ctx, field, obj)
1428			if out.Values[i] == graphql.Null {
1429				invalid = true
1430			}
1431		case "files":
1432			out.Values[i] = ec._AddCommentOperation_files(ctx, field, obj)
1433			if out.Values[i] == graphql.Null {
1434				invalid = true
1435			}
1436		default:
1437			panic("unknown field " + strconv.Quote(field.Name))
1438		}
1439	}
1440	wg.Wait()
1441	if invalid {
1442		return graphql.Null
1443	}
1444	return out
1445}
1446
1447// nolint: vetshadow
1448func (ec *executionContext) _AddCommentOperation_author(ctx context.Context, field graphql.CollectedField, obj *operations.AddCommentOperation) graphql.Marshaler {
1449	rctx := &graphql.ResolverContext{
1450		Object: "AddCommentOperation",
1451		Args:   nil,
1452		Field:  field,
1453	}
1454	ctx = graphql.WithResolverContext(ctx, rctx)
1455	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
1456		return obj.Author, nil
1457	})
1458	if resTmp == nil {
1459		if !ec.HasError(rctx) {
1460			ec.Errorf(ctx, "must not be null")
1461		}
1462		return graphql.Null
1463	}
1464	res := resTmp.(bug.Person)
1465	rctx.Result = res
1466
1467	return ec._Person(ctx, field.Selections, &res)
1468}
1469
1470// nolint: vetshadow
1471func (ec *executionContext) _AddCommentOperation_date(ctx context.Context, field graphql.CollectedField, obj *operations.AddCommentOperation) graphql.Marshaler {
1472	rctx := &graphql.ResolverContext{
1473		Object: "AddCommentOperation",
1474		Args:   nil,
1475		Field:  field,
1476	}
1477	ctx = graphql.WithResolverContext(ctx, rctx)
1478	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
1479		return ec.resolvers.AddCommentOperation().Date(ctx, obj)
1480	})
1481	if resTmp == nil {
1482		if !ec.HasError(rctx) {
1483			ec.Errorf(ctx, "must not be null")
1484		}
1485		return graphql.Null
1486	}
1487	res := resTmp.(time.Time)
1488	rctx.Result = res
1489	return graphql.MarshalTime(res)
1490}
1491
1492// nolint: vetshadow
1493func (ec *executionContext) _AddCommentOperation_message(ctx context.Context, field graphql.CollectedField, obj *operations.AddCommentOperation) graphql.Marshaler {
1494	rctx := &graphql.ResolverContext{
1495		Object: "AddCommentOperation",
1496		Args:   nil,
1497		Field:  field,
1498	}
1499	ctx = graphql.WithResolverContext(ctx, rctx)
1500	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
1501		return obj.Message, nil
1502	})
1503	if resTmp == nil {
1504		if !ec.HasError(rctx) {
1505			ec.Errorf(ctx, "must not be null")
1506		}
1507		return graphql.Null
1508	}
1509	res := resTmp.(string)
1510	rctx.Result = res
1511	return graphql.MarshalString(res)
1512}
1513
1514// nolint: vetshadow
1515func (ec *executionContext) _AddCommentOperation_files(ctx context.Context, field graphql.CollectedField, obj *operations.AddCommentOperation) graphql.Marshaler {
1516	rctx := &graphql.ResolverContext{
1517		Object: "AddCommentOperation",
1518		Args:   nil,
1519		Field:  field,
1520	}
1521	ctx = graphql.WithResolverContext(ctx, rctx)
1522	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
1523		return obj.Files, nil
1524	})
1525	if resTmp == nil {
1526		if !ec.HasError(rctx) {
1527			ec.Errorf(ctx, "must not be null")
1528		}
1529		return graphql.Null
1530	}
1531	res := resTmp.([]git.Hash)
1532	rctx.Result = res
1533
1534	arr1 := make(graphql.Array, len(res))
1535
1536	for idx1 := range res {
1537		arr1[idx1] = func() graphql.Marshaler {
1538			return res[idx1]
1539		}()
1540	}
1541
1542	return arr1
1543}
1544
1545var bugImplementors = []string{"Bug"}
1546
1547// nolint: gocyclo, errcheck, gas, goconst
1548func (ec *executionContext) _Bug(ctx context.Context, sel ast.SelectionSet, obj *bug.Snapshot) graphql.Marshaler {
1549	fields := graphql.CollectFields(ctx, sel, bugImplementors)
1550
1551	var wg sync.WaitGroup
1552	out := graphql.NewOrderedMap(len(fields))
1553	invalid := false
1554	for i, field := range fields {
1555		out.Keys[i] = field.Alias
1556
1557		switch field.Name {
1558		case "__typename":
1559			out.Values[i] = graphql.MarshalString("Bug")
1560		case "id":
1561			out.Values[i] = ec._Bug_id(ctx, field, obj)
1562			if out.Values[i] == graphql.Null {
1563				invalid = true
1564			}
1565		case "humanId":
1566			out.Values[i] = ec._Bug_humanId(ctx, field, obj)
1567			if out.Values[i] == graphql.Null {
1568				invalid = true
1569			}
1570		case "status":
1571			wg.Add(1)
1572			go func(i int, field graphql.CollectedField) {
1573				out.Values[i] = ec._Bug_status(ctx, field, obj)
1574				if out.Values[i] == graphql.Null {
1575					invalid = true
1576				}
1577				wg.Done()
1578			}(i, field)
1579		case "title":
1580			out.Values[i] = ec._Bug_title(ctx, field, obj)
1581			if out.Values[i] == graphql.Null {
1582				invalid = true
1583			}
1584		case "labels":
1585			out.Values[i] = ec._Bug_labels(ctx, field, obj)
1586			if out.Values[i] == graphql.Null {
1587				invalid = true
1588			}
1589		case "author":
1590			out.Values[i] = ec._Bug_author(ctx, field, obj)
1591			if out.Values[i] == graphql.Null {
1592				invalid = true
1593			}
1594		case "createdAt":
1595			out.Values[i] = ec._Bug_createdAt(ctx, field, obj)
1596			if out.Values[i] == graphql.Null {
1597				invalid = true
1598			}
1599		case "lastEdit":
1600			wg.Add(1)
1601			go func(i int, field graphql.CollectedField) {
1602				out.Values[i] = ec._Bug_lastEdit(ctx, field, obj)
1603				if out.Values[i] == graphql.Null {
1604					invalid = true
1605				}
1606				wg.Done()
1607			}(i, field)
1608		case "comments":
1609			wg.Add(1)
1610			go func(i int, field graphql.CollectedField) {
1611				out.Values[i] = ec._Bug_comments(ctx, field, obj)
1612				if out.Values[i] == graphql.Null {
1613					invalid = true
1614				}
1615				wg.Done()
1616			}(i, field)
1617		case "operations":
1618			wg.Add(1)
1619			go func(i int, field graphql.CollectedField) {
1620				out.Values[i] = ec._Bug_operations(ctx, field, obj)
1621				if out.Values[i] == graphql.Null {
1622					invalid = true
1623				}
1624				wg.Done()
1625			}(i, field)
1626		default:
1627			panic("unknown field " + strconv.Quote(field.Name))
1628		}
1629	}
1630	wg.Wait()
1631	if invalid {
1632		return graphql.Null
1633	}
1634	return out
1635}
1636
1637// nolint: vetshadow
1638func (ec *executionContext) _Bug_id(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
1639	rctx := &graphql.ResolverContext{
1640		Object: "Bug",
1641		Args:   nil,
1642		Field:  field,
1643	}
1644	ctx = graphql.WithResolverContext(ctx, rctx)
1645	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
1646		return obj.Id(), nil
1647	})
1648	if resTmp == nil {
1649		if !ec.HasError(rctx) {
1650			ec.Errorf(ctx, "must not be null")
1651		}
1652		return graphql.Null
1653	}
1654	res := resTmp.(string)
1655	rctx.Result = res
1656	return graphql.MarshalString(res)
1657}
1658
1659// nolint: vetshadow
1660func (ec *executionContext) _Bug_humanId(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
1661	rctx := &graphql.ResolverContext{
1662		Object: "Bug",
1663		Args:   nil,
1664		Field:  field,
1665	}
1666	ctx = graphql.WithResolverContext(ctx, rctx)
1667	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
1668		return obj.HumanId(), nil
1669	})
1670	if resTmp == nil {
1671		if !ec.HasError(rctx) {
1672			ec.Errorf(ctx, "must not be null")
1673		}
1674		return graphql.Null
1675	}
1676	res := resTmp.(string)
1677	rctx.Result = res
1678	return graphql.MarshalString(res)
1679}
1680
1681// nolint: vetshadow
1682func (ec *executionContext) _Bug_status(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
1683	rctx := &graphql.ResolverContext{
1684		Object: "Bug",
1685		Args:   nil,
1686		Field:  field,
1687	}
1688	ctx = graphql.WithResolverContext(ctx, rctx)
1689	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
1690		return ec.resolvers.Bug().Status(ctx, obj)
1691	})
1692	if resTmp == nil {
1693		if !ec.HasError(rctx) {
1694			ec.Errorf(ctx, "must not be null")
1695		}
1696		return graphql.Null
1697	}
1698	res := resTmp.(models.Status)
1699	rctx.Result = res
1700	return res
1701}
1702
1703// nolint: vetshadow
1704func (ec *executionContext) _Bug_title(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
1705	rctx := &graphql.ResolverContext{
1706		Object: "Bug",
1707		Args:   nil,
1708		Field:  field,
1709	}
1710	ctx = graphql.WithResolverContext(ctx, rctx)
1711	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
1712		return obj.Title, nil
1713	})
1714	if resTmp == nil {
1715		if !ec.HasError(rctx) {
1716			ec.Errorf(ctx, "must not be null")
1717		}
1718		return graphql.Null
1719	}
1720	res := resTmp.(string)
1721	rctx.Result = res
1722	return graphql.MarshalString(res)
1723}
1724
1725// nolint: vetshadow
1726func (ec *executionContext) _Bug_labels(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
1727	rctx := &graphql.ResolverContext{
1728		Object: "Bug",
1729		Args:   nil,
1730		Field:  field,
1731	}
1732	ctx = graphql.WithResolverContext(ctx, rctx)
1733	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
1734		return obj.Labels, nil
1735	})
1736	if resTmp == nil {
1737		if !ec.HasError(rctx) {
1738			ec.Errorf(ctx, "must not be null")
1739		}
1740		return graphql.Null
1741	}
1742	res := resTmp.([]bug.Label)
1743	rctx.Result = res
1744
1745	arr1 := make(graphql.Array, len(res))
1746
1747	for idx1 := range res {
1748		arr1[idx1] = func() graphql.Marshaler {
1749			return res[idx1]
1750		}()
1751	}
1752
1753	return arr1
1754}
1755
1756// nolint: vetshadow
1757func (ec *executionContext) _Bug_author(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
1758	rctx := &graphql.ResolverContext{
1759		Object: "Bug",
1760		Args:   nil,
1761		Field:  field,
1762	}
1763	ctx = graphql.WithResolverContext(ctx, rctx)
1764	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
1765		return obj.Author, nil
1766	})
1767	if resTmp == nil {
1768		if !ec.HasError(rctx) {
1769			ec.Errorf(ctx, "must not be null")
1770		}
1771		return graphql.Null
1772	}
1773	res := resTmp.(bug.Person)
1774	rctx.Result = res
1775
1776	return ec._Person(ctx, field.Selections, &res)
1777}
1778
1779// nolint: vetshadow
1780func (ec *executionContext) _Bug_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
1781	rctx := &graphql.ResolverContext{
1782		Object: "Bug",
1783		Args:   nil,
1784		Field:  field,
1785	}
1786	ctx = graphql.WithResolverContext(ctx, rctx)
1787	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
1788		return obj.CreatedAt, nil
1789	})
1790	if resTmp == nil {
1791		if !ec.HasError(rctx) {
1792			ec.Errorf(ctx, "must not be null")
1793		}
1794		return graphql.Null
1795	}
1796	res := resTmp.(time.Time)
1797	rctx.Result = res
1798	return graphql.MarshalTime(res)
1799}
1800
1801// nolint: vetshadow
1802func (ec *executionContext) _Bug_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
1803	rctx := &graphql.ResolverContext{
1804		Object: "Bug",
1805		Args:   nil,
1806		Field:  field,
1807	}
1808	ctx = graphql.WithResolverContext(ctx, rctx)
1809	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
1810		return ec.resolvers.Bug().LastEdit(ctx, obj)
1811	})
1812	if resTmp == nil {
1813		if !ec.HasError(rctx) {
1814			ec.Errorf(ctx, "must not be null")
1815		}
1816		return graphql.Null
1817	}
1818	res := resTmp.(time.Time)
1819	rctx.Result = res
1820	return graphql.MarshalTime(res)
1821}
1822
1823// nolint: vetshadow
1824func (ec *executionContext) _Bug_comments(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
1825	rawArgs := field.ArgumentMap(ec.Variables)
1826	args, err := field_Bug_comments_args(rawArgs)
1827	if err != nil {
1828		ec.Error(ctx, err)
1829		return graphql.Null
1830	}
1831	rctx := &graphql.ResolverContext{
1832		Object: "Bug",
1833		Args:   args,
1834		Field:  field,
1835	}
1836	ctx = graphql.WithResolverContext(ctx, rctx)
1837	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
1838		return ec.resolvers.Bug().Comments(ctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
1839	})
1840	if resTmp == nil {
1841		if !ec.HasError(rctx) {
1842			ec.Errorf(ctx, "must not be null")
1843		}
1844		return graphql.Null
1845	}
1846	res := resTmp.(models.CommentConnection)
1847	rctx.Result = res
1848
1849	return ec._CommentConnection(ctx, field.Selections, &res)
1850}
1851
1852// nolint: vetshadow
1853func (ec *executionContext) _Bug_operations(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
1854	rawArgs := field.ArgumentMap(ec.Variables)
1855	args, err := field_Bug_operations_args(rawArgs)
1856	if err != nil {
1857		ec.Error(ctx, err)
1858		return graphql.Null
1859	}
1860	rctx := &graphql.ResolverContext{
1861		Object: "Bug",
1862		Args:   args,
1863		Field:  field,
1864	}
1865	ctx = graphql.WithResolverContext(ctx, rctx)
1866	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
1867		return ec.resolvers.Bug().Operations(ctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
1868	})
1869	if resTmp == nil {
1870		if !ec.HasError(rctx) {
1871			ec.Errorf(ctx, "must not be null")
1872		}
1873		return graphql.Null
1874	}
1875	res := resTmp.(models.OperationConnection)
1876	rctx.Result = res
1877
1878	return ec._OperationConnection(ctx, field.Selections, &res)
1879}
1880
1881var bugConnectionImplementors = []string{"BugConnection"}
1882
1883// nolint: gocyclo, errcheck, gas, goconst
1884func (ec *executionContext) _BugConnection(ctx context.Context, sel ast.SelectionSet, obj *models.BugConnection) graphql.Marshaler {
1885	fields := graphql.CollectFields(ctx, sel, bugConnectionImplementors)
1886
1887	out := graphql.NewOrderedMap(len(fields))
1888	invalid := false
1889	for i, field := range fields {
1890		out.Keys[i] = field.Alias
1891
1892		switch field.Name {
1893		case "__typename":
1894			out.Values[i] = graphql.MarshalString("BugConnection")
1895		case "edges":
1896			out.Values[i] = ec._BugConnection_edges(ctx, field, obj)
1897			if out.Values[i] == graphql.Null {
1898				invalid = true
1899			}
1900		case "nodes":
1901			out.Values[i] = ec._BugConnection_nodes(ctx, field, obj)
1902			if out.Values[i] == graphql.Null {
1903				invalid = true
1904			}
1905		case "pageInfo":
1906			out.Values[i] = ec._BugConnection_pageInfo(ctx, field, obj)
1907			if out.Values[i] == graphql.Null {
1908				invalid = true
1909			}
1910		case "totalCount":
1911			out.Values[i] = ec._BugConnection_totalCount(ctx, field, obj)
1912			if out.Values[i] == graphql.Null {
1913				invalid = true
1914			}
1915		default:
1916			panic("unknown field " + strconv.Quote(field.Name))
1917		}
1918	}
1919
1920	if invalid {
1921		return graphql.Null
1922	}
1923	return out
1924}
1925
1926// nolint: vetshadow
1927func (ec *executionContext) _BugConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) graphql.Marshaler {
1928	rctx := &graphql.ResolverContext{
1929		Object: "BugConnection",
1930		Args:   nil,
1931		Field:  field,
1932	}
1933	ctx = graphql.WithResolverContext(ctx, rctx)
1934	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
1935		return obj.Edges, nil
1936	})
1937	if resTmp == nil {
1938		if !ec.HasError(rctx) {
1939			ec.Errorf(ctx, "must not be null")
1940		}
1941		return graphql.Null
1942	}
1943	res := resTmp.([]models.BugEdge)
1944	rctx.Result = res
1945
1946	arr1 := make(graphql.Array, len(res))
1947	var wg sync.WaitGroup
1948
1949	isLen1 := len(res) == 1
1950	if !isLen1 {
1951		wg.Add(len(res))
1952	}
1953
1954	for idx1 := range res {
1955		idx1 := idx1
1956		rctx := &graphql.ResolverContext{
1957			Index:  &idx1,
1958			Result: &res[idx1],
1959		}
1960		ctx := graphql.WithResolverContext(ctx, rctx)
1961		f := func(idx1 int) {
1962			if !isLen1 {
1963				defer wg.Done()
1964			}
1965			arr1[idx1] = func() graphql.Marshaler {
1966
1967				return ec._BugEdge(ctx, field.Selections, &res[idx1])
1968			}()
1969		}
1970		if isLen1 {
1971			f(idx1)
1972		} else {
1973			go f(idx1)
1974		}
1975
1976	}
1977	wg.Wait()
1978	return arr1
1979}
1980
1981// nolint: vetshadow
1982func (ec *executionContext) _BugConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) graphql.Marshaler {
1983	rctx := &graphql.ResolverContext{
1984		Object: "BugConnection",
1985		Args:   nil,
1986		Field:  field,
1987	}
1988	ctx = graphql.WithResolverContext(ctx, rctx)
1989	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
1990		return obj.Nodes, nil
1991	})
1992	if resTmp == nil {
1993		if !ec.HasError(rctx) {
1994			ec.Errorf(ctx, "must not be null")
1995		}
1996		return graphql.Null
1997	}
1998	res := resTmp.([]bug.Snapshot)
1999	rctx.Result = res
2000
2001	arr1 := make(graphql.Array, len(res))
2002	var wg sync.WaitGroup
2003
2004	isLen1 := len(res) == 1
2005	if !isLen1 {
2006		wg.Add(len(res))
2007	}
2008
2009	for idx1 := range res {
2010		idx1 := idx1
2011		rctx := &graphql.ResolverContext{
2012			Index:  &idx1,
2013			Result: &res[idx1],
2014		}
2015		ctx := graphql.WithResolverContext(ctx, rctx)
2016		f := func(idx1 int) {
2017			if !isLen1 {
2018				defer wg.Done()
2019			}
2020			arr1[idx1] = func() graphql.Marshaler {
2021
2022				return ec._Bug(ctx, field.Selections, &res[idx1])
2023			}()
2024		}
2025		if isLen1 {
2026			f(idx1)
2027		} else {
2028			go f(idx1)
2029		}
2030
2031	}
2032	wg.Wait()
2033	return arr1
2034}
2035
2036// nolint: vetshadow
2037func (ec *executionContext) _BugConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) graphql.Marshaler {
2038	rctx := &graphql.ResolverContext{
2039		Object: "BugConnection",
2040		Args:   nil,
2041		Field:  field,
2042	}
2043	ctx = graphql.WithResolverContext(ctx, rctx)
2044	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
2045		return obj.PageInfo, nil
2046	})
2047	if resTmp == nil {
2048		if !ec.HasError(rctx) {
2049			ec.Errorf(ctx, "must not be null")
2050		}
2051		return graphql.Null
2052	}
2053	res := resTmp.(models.PageInfo)
2054	rctx.Result = res
2055
2056	return ec._PageInfo(ctx, field.Selections, &res)
2057}
2058
2059// nolint: vetshadow
2060func (ec *executionContext) _BugConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) graphql.Marshaler {
2061	rctx := &graphql.ResolverContext{
2062		Object: "BugConnection",
2063		Args:   nil,
2064		Field:  field,
2065	}
2066	ctx = graphql.WithResolverContext(ctx, rctx)
2067	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
2068		return obj.TotalCount, nil
2069	})
2070	if resTmp == nil {
2071		if !ec.HasError(rctx) {
2072			ec.Errorf(ctx, "must not be null")
2073		}
2074		return graphql.Null
2075	}
2076	res := resTmp.(int)
2077	rctx.Result = res
2078	return graphql.MarshalInt(res)
2079}
2080
2081var bugEdgeImplementors = []string{"BugEdge"}
2082
2083// nolint: gocyclo, errcheck, gas, goconst
2084func (ec *executionContext) _BugEdge(ctx context.Context, sel ast.SelectionSet, obj *models.BugEdge) graphql.Marshaler {
2085	fields := graphql.CollectFields(ctx, sel, bugEdgeImplementors)
2086
2087	out := graphql.NewOrderedMap(len(fields))
2088	invalid := false
2089	for i, field := range fields {
2090		out.Keys[i] = field.Alias
2091
2092		switch field.Name {
2093		case "__typename":
2094			out.Values[i] = graphql.MarshalString("BugEdge")
2095		case "cursor":
2096			out.Values[i] = ec._BugEdge_cursor(ctx, field, obj)
2097			if out.Values[i] == graphql.Null {
2098				invalid = true
2099			}
2100		case "node":
2101			out.Values[i] = ec._BugEdge_node(ctx, field, obj)
2102			if out.Values[i] == graphql.Null {
2103				invalid = true
2104			}
2105		default:
2106			panic("unknown field " + strconv.Quote(field.Name))
2107		}
2108	}
2109
2110	if invalid {
2111		return graphql.Null
2112	}
2113	return out
2114}
2115
2116// nolint: vetshadow
2117func (ec *executionContext) _BugEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.BugEdge) graphql.Marshaler {
2118	rctx := &graphql.ResolverContext{
2119		Object: "BugEdge",
2120		Args:   nil,
2121		Field:  field,
2122	}
2123	ctx = graphql.WithResolverContext(ctx, rctx)
2124	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
2125		return obj.Cursor, nil
2126	})
2127	if resTmp == nil {
2128		if !ec.HasError(rctx) {
2129			ec.Errorf(ctx, "must not be null")
2130		}
2131		return graphql.Null
2132	}
2133	res := resTmp.(string)
2134	rctx.Result = res
2135	return graphql.MarshalString(res)
2136}
2137
2138// nolint: vetshadow
2139func (ec *executionContext) _BugEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.BugEdge) graphql.Marshaler {
2140	rctx := &graphql.ResolverContext{
2141		Object: "BugEdge",
2142		Args:   nil,
2143		Field:  field,
2144	}
2145	ctx = graphql.WithResolverContext(ctx, rctx)
2146	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
2147		return obj.Node, nil
2148	})
2149	if resTmp == nil {
2150		if !ec.HasError(rctx) {
2151			ec.Errorf(ctx, "must not be null")
2152		}
2153		return graphql.Null
2154	}
2155	res := resTmp.(bug.Snapshot)
2156	rctx.Result = res
2157
2158	return ec._Bug(ctx, field.Selections, &res)
2159}
2160
2161var commentImplementors = []string{"Comment", "Authored"}
2162
2163// nolint: gocyclo, errcheck, gas, goconst
2164func (ec *executionContext) _Comment(ctx context.Context, sel ast.SelectionSet, obj *bug.Comment) graphql.Marshaler {
2165	fields := graphql.CollectFields(ctx, sel, commentImplementors)
2166
2167	out := graphql.NewOrderedMap(len(fields))
2168	invalid := false
2169	for i, field := range fields {
2170		out.Keys[i] = field.Alias
2171
2172		switch field.Name {
2173		case "__typename":
2174			out.Values[i] = graphql.MarshalString("Comment")
2175		case "author":
2176			out.Values[i] = ec._Comment_author(ctx, field, obj)
2177			if out.Values[i] == graphql.Null {
2178				invalid = true
2179			}
2180		case "message":
2181			out.Values[i] = ec._Comment_message(ctx, field, obj)
2182			if out.Values[i] == graphql.Null {
2183				invalid = true
2184			}
2185		case "files":
2186			out.Values[i] = ec._Comment_files(ctx, field, obj)
2187			if out.Values[i] == graphql.Null {
2188				invalid = true
2189			}
2190		default:
2191			panic("unknown field " + strconv.Quote(field.Name))
2192		}
2193	}
2194
2195	if invalid {
2196		return graphql.Null
2197	}
2198	return out
2199}
2200
2201// nolint: vetshadow
2202func (ec *executionContext) _Comment_author(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) graphql.Marshaler {
2203	rctx := &graphql.ResolverContext{
2204		Object: "Comment",
2205		Args:   nil,
2206		Field:  field,
2207	}
2208	ctx = graphql.WithResolverContext(ctx, rctx)
2209	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
2210		return obj.Author, nil
2211	})
2212	if resTmp == nil {
2213		if !ec.HasError(rctx) {
2214			ec.Errorf(ctx, "must not be null")
2215		}
2216		return graphql.Null
2217	}
2218	res := resTmp.(bug.Person)
2219	rctx.Result = res
2220
2221	return ec._Person(ctx, field.Selections, &res)
2222}
2223
2224// nolint: vetshadow
2225func (ec *executionContext) _Comment_message(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) graphql.Marshaler {
2226	rctx := &graphql.ResolverContext{
2227		Object: "Comment",
2228		Args:   nil,
2229		Field:  field,
2230	}
2231	ctx = graphql.WithResolverContext(ctx, rctx)
2232	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
2233		return obj.Message, nil
2234	})
2235	if resTmp == nil {
2236		if !ec.HasError(rctx) {
2237			ec.Errorf(ctx, "must not be null")
2238		}
2239		return graphql.Null
2240	}
2241	res := resTmp.(string)
2242	rctx.Result = res
2243	return graphql.MarshalString(res)
2244}
2245
2246// nolint: vetshadow
2247func (ec *executionContext) _Comment_files(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) graphql.Marshaler {
2248	rctx := &graphql.ResolverContext{
2249		Object: "Comment",
2250		Args:   nil,
2251		Field:  field,
2252	}
2253	ctx = graphql.WithResolverContext(ctx, rctx)
2254	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
2255		return obj.Files, nil
2256	})
2257	if resTmp == nil {
2258		if !ec.HasError(rctx) {
2259			ec.Errorf(ctx, "must not be null")
2260		}
2261		return graphql.Null
2262	}
2263	res := resTmp.([]git.Hash)
2264	rctx.Result = res
2265
2266	arr1 := make(graphql.Array, len(res))
2267
2268	for idx1 := range res {
2269		arr1[idx1] = func() graphql.Marshaler {
2270			return res[idx1]
2271		}()
2272	}
2273
2274	return arr1
2275}
2276
2277var commentConnectionImplementors = []string{"CommentConnection"}
2278
2279// nolint: gocyclo, errcheck, gas, goconst
2280func (ec *executionContext) _CommentConnection(ctx context.Context, sel ast.SelectionSet, obj *models.CommentConnection) graphql.Marshaler {
2281	fields := graphql.CollectFields(ctx, sel, commentConnectionImplementors)
2282
2283	out := graphql.NewOrderedMap(len(fields))
2284	invalid := false
2285	for i, field := range fields {
2286		out.Keys[i] = field.Alias
2287
2288		switch field.Name {
2289		case "__typename":
2290			out.Values[i] = graphql.MarshalString("CommentConnection")
2291		case "edges":
2292			out.Values[i] = ec._CommentConnection_edges(ctx, field, obj)
2293			if out.Values[i] == graphql.Null {
2294				invalid = true
2295			}
2296		case "nodes":
2297			out.Values[i] = ec._CommentConnection_nodes(ctx, field, obj)
2298			if out.Values[i] == graphql.Null {
2299				invalid = true
2300			}
2301		case "pageInfo":
2302			out.Values[i] = ec._CommentConnection_pageInfo(ctx, field, obj)
2303			if out.Values[i] == graphql.Null {
2304				invalid = true
2305			}
2306		case "totalCount":
2307			out.Values[i] = ec._CommentConnection_totalCount(ctx, field, obj)
2308			if out.Values[i] == graphql.Null {
2309				invalid = true
2310			}
2311		default:
2312			panic("unknown field " + strconv.Quote(field.Name))
2313		}
2314	}
2315
2316	if invalid {
2317		return graphql.Null
2318	}
2319	return out
2320}
2321
2322// nolint: vetshadow
2323func (ec *executionContext) _CommentConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) graphql.Marshaler {
2324	rctx := &graphql.ResolverContext{
2325		Object: "CommentConnection",
2326		Args:   nil,
2327		Field:  field,
2328	}
2329	ctx = graphql.WithResolverContext(ctx, rctx)
2330	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
2331		return obj.Edges, nil
2332	})
2333	if resTmp == nil {
2334		if !ec.HasError(rctx) {
2335			ec.Errorf(ctx, "must not be null")
2336		}
2337		return graphql.Null
2338	}
2339	res := resTmp.([]models.CommentEdge)
2340	rctx.Result = res
2341
2342	arr1 := make(graphql.Array, len(res))
2343	var wg sync.WaitGroup
2344
2345	isLen1 := len(res) == 1
2346	if !isLen1 {
2347		wg.Add(len(res))
2348	}
2349
2350	for idx1 := range res {
2351		idx1 := idx1
2352		rctx := &graphql.ResolverContext{
2353			Index:  &idx1,
2354			Result: &res[idx1],
2355		}
2356		ctx := graphql.WithResolverContext(ctx, rctx)
2357		f := func(idx1 int) {
2358			if !isLen1 {
2359				defer wg.Done()
2360			}
2361			arr1[idx1] = func() graphql.Marshaler {
2362
2363				return ec._CommentEdge(ctx, field.Selections, &res[idx1])
2364			}()
2365		}
2366		if isLen1 {
2367			f(idx1)
2368		} else {
2369			go f(idx1)
2370		}
2371
2372	}
2373	wg.Wait()
2374	return arr1
2375}
2376
2377// nolint: vetshadow
2378func (ec *executionContext) _CommentConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) graphql.Marshaler {
2379	rctx := &graphql.ResolverContext{
2380		Object: "CommentConnection",
2381		Args:   nil,
2382		Field:  field,
2383	}
2384	ctx = graphql.WithResolverContext(ctx, rctx)
2385	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
2386		return obj.Nodes, nil
2387	})
2388	if resTmp == nil {
2389		if !ec.HasError(rctx) {
2390			ec.Errorf(ctx, "must not be null")
2391		}
2392		return graphql.Null
2393	}
2394	res := resTmp.([]bug.Comment)
2395	rctx.Result = res
2396
2397	arr1 := make(graphql.Array, len(res))
2398	var wg sync.WaitGroup
2399
2400	isLen1 := len(res) == 1
2401	if !isLen1 {
2402		wg.Add(len(res))
2403	}
2404
2405	for idx1 := range res {
2406		idx1 := idx1
2407		rctx := &graphql.ResolverContext{
2408			Index:  &idx1,
2409			Result: &res[idx1],
2410		}
2411		ctx := graphql.WithResolverContext(ctx, rctx)
2412		f := func(idx1 int) {
2413			if !isLen1 {
2414				defer wg.Done()
2415			}
2416			arr1[idx1] = func() graphql.Marshaler {
2417
2418				return ec._Comment(ctx, field.Selections, &res[idx1])
2419			}()
2420		}
2421		if isLen1 {
2422			f(idx1)
2423		} else {
2424			go f(idx1)
2425		}
2426
2427	}
2428	wg.Wait()
2429	return arr1
2430}
2431
2432// nolint: vetshadow
2433func (ec *executionContext) _CommentConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) graphql.Marshaler {
2434	rctx := &graphql.ResolverContext{
2435		Object: "CommentConnection",
2436		Args:   nil,
2437		Field:  field,
2438	}
2439	ctx = graphql.WithResolverContext(ctx, rctx)
2440	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
2441		return obj.PageInfo, nil
2442	})
2443	if resTmp == nil {
2444		if !ec.HasError(rctx) {
2445			ec.Errorf(ctx, "must not be null")
2446		}
2447		return graphql.Null
2448	}
2449	res := resTmp.(models.PageInfo)
2450	rctx.Result = res
2451
2452	return ec._PageInfo(ctx, field.Selections, &res)
2453}
2454
2455// nolint: vetshadow
2456func (ec *executionContext) _CommentConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) graphql.Marshaler {
2457	rctx := &graphql.ResolverContext{
2458		Object: "CommentConnection",
2459		Args:   nil,
2460		Field:  field,
2461	}
2462	ctx = graphql.WithResolverContext(ctx, rctx)
2463	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
2464		return obj.TotalCount, nil
2465	})
2466	if resTmp == nil {
2467		if !ec.HasError(rctx) {
2468			ec.Errorf(ctx, "must not be null")
2469		}
2470		return graphql.Null
2471	}
2472	res := resTmp.(int)
2473	rctx.Result = res
2474	return graphql.MarshalInt(res)
2475}
2476
2477var commentEdgeImplementors = []string{"CommentEdge"}
2478
2479// nolint: gocyclo, errcheck, gas, goconst
2480func (ec *executionContext) _CommentEdge(ctx context.Context, sel ast.SelectionSet, obj *models.CommentEdge) graphql.Marshaler {
2481	fields := graphql.CollectFields(ctx, sel, commentEdgeImplementors)
2482
2483	out := graphql.NewOrderedMap(len(fields))
2484	invalid := false
2485	for i, field := range fields {
2486		out.Keys[i] = field.Alias
2487
2488		switch field.Name {
2489		case "__typename":
2490			out.Values[i] = graphql.MarshalString("CommentEdge")
2491		case "cursor":
2492			out.Values[i] = ec._CommentEdge_cursor(ctx, field, obj)
2493			if out.Values[i] == graphql.Null {
2494				invalid = true
2495			}
2496		case "node":
2497			out.Values[i] = ec._CommentEdge_node(ctx, field, obj)
2498			if out.Values[i] == graphql.Null {
2499				invalid = true
2500			}
2501		default:
2502			panic("unknown field " + strconv.Quote(field.Name))
2503		}
2504	}
2505
2506	if invalid {
2507		return graphql.Null
2508	}
2509	return out
2510}
2511
2512// nolint: vetshadow
2513func (ec *executionContext) _CommentEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.CommentEdge) graphql.Marshaler {
2514	rctx := &graphql.ResolverContext{
2515		Object: "CommentEdge",
2516		Args:   nil,
2517		Field:  field,
2518	}
2519	ctx = graphql.WithResolverContext(ctx, rctx)
2520	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
2521		return obj.Cursor, nil
2522	})
2523	if resTmp == nil {
2524		if !ec.HasError(rctx) {
2525			ec.Errorf(ctx, "must not be null")
2526		}
2527		return graphql.Null
2528	}
2529	res := resTmp.(string)
2530	rctx.Result = res
2531	return graphql.MarshalString(res)
2532}
2533
2534// nolint: vetshadow
2535func (ec *executionContext) _CommentEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.CommentEdge) graphql.Marshaler {
2536	rctx := &graphql.ResolverContext{
2537		Object: "CommentEdge",
2538		Args:   nil,
2539		Field:  field,
2540	}
2541	ctx = graphql.WithResolverContext(ctx, rctx)
2542	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
2543		return obj.Node, nil
2544	})
2545	if resTmp == nil {
2546		if !ec.HasError(rctx) {
2547			ec.Errorf(ctx, "must not be null")
2548		}
2549		return graphql.Null
2550	}
2551	res := resTmp.(bug.Comment)
2552	rctx.Result = res
2553
2554	return ec._Comment(ctx, field.Selections, &res)
2555}
2556
2557var createOperationImplementors = []string{"CreateOperation", "Operation", "Authored"}
2558
2559// nolint: gocyclo, errcheck, gas, goconst
2560func (ec *executionContext) _CreateOperation(ctx context.Context, sel ast.SelectionSet, obj *operations.CreateOperation) graphql.Marshaler {
2561	fields := graphql.CollectFields(ctx, sel, createOperationImplementors)
2562
2563	var wg sync.WaitGroup
2564	out := graphql.NewOrderedMap(len(fields))
2565	invalid := false
2566	for i, field := range fields {
2567		out.Keys[i] = field.Alias
2568
2569		switch field.Name {
2570		case "__typename":
2571			out.Values[i] = graphql.MarshalString("CreateOperation")
2572		case "author":
2573			out.Values[i] = ec._CreateOperation_author(ctx, field, obj)
2574			if out.Values[i] == graphql.Null {
2575				invalid = true
2576			}
2577		case "date":
2578			wg.Add(1)
2579			go func(i int, field graphql.CollectedField) {
2580				out.Values[i] = ec._CreateOperation_date(ctx, field, obj)
2581				if out.Values[i] == graphql.Null {
2582					invalid = true
2583				}
2584				wg.Done()
2585			}(i, field)
2586		case "title":
2587			out.Values[i] = ec._CreateOperation_title(ctx, field, obj)
2588			if out.Values[i] == graphql.Null {
2589				invalid = true
2590			}
2591		case "message":
2592			out.Values[i] = ec._CreateOperation_message(ctx, field, obj)
2593			if out.Values[i] == graphql.Null {
2594				invalid = true
2595			}
2596		case "files":
2597			out.Values[i] = ec._CreateOperation_files(ctx, field, obj)
2598			if out.Values[i] == graphql.Null {
2599				invalid = true
2600			}
2601		default:
2602			panic("unknown field " + strconv.Quote(field.Name))
2603		}
2604	}
2605	wg.Wait()
2606	if invalid {
2607		return graphql.Null
2608	}
2609	return out
2610}
2611
2612// nolint: vetshadow
2613func (ec *executionContext) _CreateOperation_author(ctx context.Context, field graphql.CollectedField, obj *operations.CreateOperation) graphql.Marshaler {
2614	rctx := &graphql.ResolverContext{
2615		Object: "CreateOperation",
2616		Args:   nil,
2617		Field:  field,
2618	}
2619	ctx = graphql.WithResolverContext(ctx, rctx)
2620	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
2621		return obj.Author, nil
2622	})
2623	if resTmp == nil {
2624		if !ec.HasError(rctx) {
2625			ec.Errorf(ctx, "must not be null")
2626		}
2627		return graphql.Null
2628	}
2629	res := resTmp.(bug.Person)
2630	rctx.Result = res
2631
2632	return ec._Person(ctx, field.Selections, &res)
2633}
2634
2635// nolint: vetshadow
2636func (ec *executionContext) _CreateOperation_date(ctx context.Context, field graphql.CollectedField, obj *operations.CreateOperation) graphql.Marshaler {
2637	rctx := &graphql.ResolverContext{
2638		Object: "CreateOperation",
2639		Args:   nil,
2640		Field:  field,
2641	}
2642	ctx = graphql.WithResolverContext(ctx, rctx)
2643	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
2644		return ec.resolvers.CreateOperation().Date(ctx, obj)
2645	})
2646	if resTmp == nil {
2647		if !ec.HasError(rctx) {
2648			ec.Errorf(ctx, "must not be null")
2649		}
2650		return graphql.Null
2651	}
2652	res := resTmp.(time.Time)
2653	rctx.Result = res
2654	return graphql.MarshalTime(res)
2655}
2656
2657// nolint: vetshadow
2658func (ec *executionContext) _CreateOperation_title(ctx context.Context, field graphql.CollectedField, obj *operations.CreateOperation) graphql.Marshaler {
2659	rctx := &graphql.ResolverContext{
2660		Object: "CreateOperation",
2661		Args:   nil,
2662		Field:  field,
2663	}
2664	ctx = graphql.WithResolverContext(ctx, rctx)
2665	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
2666		return obj.Title, nil
2667	})
2668	if resTmp == nil {
2669		if !ec.HasError(rctx) {
2670			ec.Errorf(ctx, "must not be null")
2671		}
2672		return graphql.Null
2673	}
2674	res := resTmp.(string)
2675	rctx.Result = res
2676	return graphql.MarshalString(res)
2677}
2678
2679// nolint: vetshadow
2680func (ec *executionContext) _CreateOperation_message(ctx context.Context, field graphql.CollectedField, obj *operations.CreateOperation) graphql.Marshaler {
2681	rctx := &graphql.ResolverContext{
2682		Object: "CreateOperation",
2683		Args:   nil,
2684		Field:  field,
2685	}
2686	ctx = graphql.WithResolverContext(ctx, rctx)
2687	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
2688		return obj.Message, nil
2689	})
2690	if resTmp == nil {
2691		if !ec.HasError(rctx) {
2692			ec.Errorf(ctx, "must not be null")
2693		}
2694		return graphql.Null
2695	}
2696	res := resTmp.(string)
2697	rctx.Result = res
2698	return graphql.MarshalString(res)
2699}
2700
2701// nolint: vetshadow
2702func (ec *executionContext) _CreateOperation_files(ctx context.Context, field graphql.CollectedField, obj *operations.CreateOperation) graphql.Marshaler {
2703	rctx := &graphql.ResolverContext{
2704		Object: "CreateOperation",
2705		Args:   nil,
2706		Field:  field,
2707	}
2708	ctx = graphql.WithResolverContext(ctx, rctx)
2709	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
2710		return obj.Files, nil
2711	})
2712	if resTmp == nil {
2713		if !ec.HasError(rctx) {
2714			ec.Errorf(ctx, "must not be null")
2715		}
2716		return graphql.Null
2717	}
2718	res := resTmp.([]git.Hash)
2719	rctx.Result = res
2720
2721	arr1 := make(graphql.Array, len(res))
2722
2723	for idx1 := range res {
2724		arr1[idx1] = func() graphql.Marshaler {
2725			return res[idx1]
2726		}()
2727	}
2728
2729	return arr1
2730}
2731
2732var labelChangeOperationImplementors = []string{"LabelChangeOperation", "Operation", "Authored"}
2733
2734// nolint: gocyclo, errcheck, gas, goconst
2735func (ec *executionContext) _LabelChangeOperation(ctx context.Context, sel ast.SelectionSet, obj *operations.LabelChangeOperation) graphql.Marshaler {
2736	fields := graphql.CollectFields(ctx, sel, labelChangeOperationImplementors)
2737
2738	var wg sync.WaitGroup
2739	out := graphql.NewOrderedMap(len(fields))
2740	invalid := false
2741	for i, field := range fields {
2742		out.Keys[i] = field.Alias
2743
2744		switch field.Name {
2745		case "__typename":
2746			out.Values[i] = graphql.MarshalString("LabelChangeOperation")
2747		case "author":
2748			out.Values[i] = ec._LabelChangeOperation_author(ctx, field, obj)
2749			if out.Values[i] == graphql.Null {
2750				invalid = true
2751			}
2752		case "date":
2753			wg.Add(1)
2754			go func(i int, field graphql.CollectedField) {
2755				out.Values[i] = ec._LabelChangeOperation_date(ctx, field, obj)
2756				if out.Values[i] == graphql.Null {
2757					invalid = true
2758				}
2759				wg.Done()
2760			}(i, field)
2761		case "added":
2762			out.Values[i] = ec._LabelChangeOperation_added(ctx, field, obj)
2763			if out.Values[i] == graphql.Null {
2764				invalid = true
2765			}
2766		case "removed":
2767			out.Values[i] = ec._LabelChangeOperation_removed(ctx, field, obj)
2768			if out.Values[i] == graphql.Null {
2769				invalid = true
2770			}
2771		default:
2772			panic("unknown field " + strconv.Quote(field.Name))
2773		}
2774	}
2775	wg.Wait()
2776	if invalid {
2777		return graphql.Null
2778	}
2779	return out
2780}
2781
2782// nolint: vetshadow
2783func (ec *executionContext) _LabelChangeOperation_author(ctx context.Context, field graphql.CollectedField, obj *operations.LabelChangeOperation) graphql.Marshaler {
2784	rctx := &graphql.ResolverContext{
2785		Object: "LabelChangeOperation",
2786		Args:   nil,
2787		Field:  field,
2788	}
2789	ctx = graphql.WithResolverContext(ctx, rctx)
2790	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
2791		return obj.Author, nil
2792	})
2793	if resTmp == nil {
2794		if !ec.HasError(rctx) {
2795			ec.Errorf(ctx, "must not be null")
2796		}
2797		return graphql.Null
2798	}
2799	res := resTmp.(bug.Person)
2800	rctx.Result = res
2801
2802	return ec._Person(ctx, field.Selections, &res)
2803}
2804
2805// nolint: vetshadow
2806func (ec *executionContext) _LabelChangeOperation_date(ctx context.Context, field graphql.CollectedField, obj *operations.LabelChangeOperation) graphql.Marshaler {
2807	rctx := &graphql.ResolverContext{
2808		Object: "LabelChangeOperation",
2809		Args:   nil,
2810		Field:  field,
2811	}
2812	ctx = graphql.WithResolverContext(ctx, rctx)
2813	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
2814		return ec.resolvers.LabelChangeOperation().Date(ctx, obj)
2815	})
2816	if resTmp == nil {
2817		if !ec.HasError(rctx) {
2818			ec.Errorf(ctx, "must not be null")
2819		}
2820		return graphql.Null
2821	}
2822	res := resTmp.(time.Time)
2823	rctx.Result = res
2824	return graphql.MarshalTime(res)
2825}
2826
2827// nolint: vetshadow
2828func (ec *executionContext) _LabelChangeOperation_added(ctx context.Context, field graphql.CollectedField, obj *operations.LabelChangeOperation) graphql.Marshaler {
2829	rctx := &graphql.ResolverContext{
2830		Object: "LabelChangeOperation",
2831		Args:   nil,
2832		Field:  field,
2833	}
2834	ctx = graphql.WithResolverContext(ctx, rctx)
2835	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
2836		return obj.Added, nil
2837	})
2838	if resTmp == nil {
2839		if !ec.HasError(rctx) {
2840			ec.Errorf(ctx, "must not be null")
2841		}
2842		return graphql.Null
2843	}
2844	res := resTmp.([]bug.Label)
2845	rctx.Result = res
2846
2847	arr1 := make(graphql.Array, len(res))
2848
2849	for idx1 := range res {
2850		arr1[idx1] = func() graphql.Marshaler {
2851			return res[idx1]
2852		}()
2853	}
2854
2855	return arr1
2856}
2857
2858// nolint: vetshadow
2859func (ec *executionContext) _LabelChangeOperation_removed(ctx context.Context, field graphql.CollectedField, obj *operations.LabelChangeOperation) graphql.Marshaler {
2860	rctx := &graphql.ResolverContext{
2861		Object: "LabelChangeOperation",
2862		Args:   nil,
2863		Field:  field,
2864	}
2865	ctx = graphql.WithResolverContext(ctx, rctx)
2866	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
2867		return obj.Removed, nil
2868	})
2869	if resTmp == nil {
2870		if !ec.HasError(rctx) {
2871			ec.Errorf(ctx, "must not be null")
2872		}
2873		return graphql.Null
2874	}
2875	res := resTmp.([]bug.Label)
2876	rctx.Result = res
2877
2878	arr1 := make(graphql.Array, len(res))
2879
2880	for idx1 := range res {
2881		arr1[idx1] = func() graphql.Marshaler {
2882			return res[idx1]
2883		}()
2884	}
2885
2886	return arr1
2887}
2888
2889var mutationImplementors = []string{"Mutation"}
2890
2891// nolint: gocyclo, errcheck, gas, goconst
2892func (ec *executionContext) _Mutation(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
2893	fields := graphql.CollectFields(ctx, sel, mutationImplementors)
2894
2895	ctx = graphql.WithResolverContext(ctx, &graphql.ResolverContext{
2896		Object: "Mutation",
2897	})
2898
2899	out := graphql.NewOrderedMap(len(fields))
2900	invalid := false
2901	for i, field := range fields {
2902		out.Keys[i] = field.Alias
2903
2904		switch field.Name {
2905		case "__typename":
2906			out.Values[i] = graphql.MarshalString("Mutation")
2907		case "newBug":
2908			out.Values[i] = ec._Mutation_newBug(ctx, field)
2909			if out.Values[i] == graphql.Null {
2910				invalid = true
2911			}
2912		case "addComment":
2913			out.Values[i] = ec._Mutation_addComment(ctx, field)
2914			if out.Values[i] == graphql.Null {
2915				invalid = true
2916			}
2917		case "changeLabels":
2918			out.Values[i] = ec._Mutation_changeLabels(ctx, field)
2919			if out.Values[i] == graphql.Null {
2920				invalid = true
2921			}
2922		case "open":
2923			out.Values[i] = ec._Mutation_open(ctx, field)
2924			if out.Values[i] == graphql.Null {
2925				invalid = true
2926			}
2927		case "close":
2928			out.Values[i] = ec._Mutation_close(ctx, field)
2929			if out.Values[i] == graphql.Null {
2930				invalid = true
2931			}
2932		case "setTitle":
2933			out.Values[i] = ec._Mutation_setTitle(ctx, field)
2934			if out.Values[i] == graphql.Null {
2935				invalid = true
2936			}
2937		case "commit":
2938			out.Values[i] = ec._Mutation_commit(ctx, field)
2939			if out.Values[i] == graphql.Null {
2940				invalid = true
2941			}
2942		default:
2943			panic("unknown field " + strconv.Quote(field.Name))
2944		}
2945	}
2946
2947	if invalid {
2948		return graphql.Null
2949	}
2950	return out
2951}
2952
2953// nolint: vetshadow
2954func (ec *executionContext) _Mutation_newBug(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
2955	rawArgs := field.ArgumentMap(ec.Variables)
2956	args, err := field_Mutation_newBug_args(rawArgs)
2957	if err != nil {
2958		ec.Error(ctx, err)
2959		return graphql.Null
2960	}
2961	rctx := &graphql.ResolverContext{
2962		Object: "Mutation",
2963		Args:   args,
2964		Field:  field,
2965	}
2966	ctx = graphql.WithResolverContext(ctx, rctx)
2967	resTmp := ec.FieldMiddleware(ctx, nil, func(ctx context.Context) (interface{}, error) {
2968		return ec.resolvers.Mutation().NewBug(ctx, args["repoRef"].(*string), args["title"].(string), args["message"].(string), args["files"].([]git.Hash))
2969	})
2970	if resTmp == nil {
2971		if !ec.HasError(rctx) {
2972			ec.Errorf(ctx, "must not be null")
2973		}
2974		return graphql.Null
2975	}
2976	res := resTmp.(bug.Snapshot)
2977	rctx.Result = res
2978
2979	return ec._Bug(ctx, field.Selections, &res)
2980}
2981
2982// nolint: vetshadow
2983func (ec *executionContext) _Mutation_addComment(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
2984	rawArgs := field.ArgumentMap(ec.Variables)
2985	args, err := field_Mutation_addComment_args(rawArgs)
2986	if err != nil {
2987		ec.Error(ctx, err)
2988		return graphql.Null
2989	}
2990	rctx := &graphql.ResolverContext{
2991		Object: "Mutation",
2992		Args:   args,
2993		Field:  field,
2994	}
2995	ctx = graphql.WithResolverContext(ctx, rctx)
2996	resTmp := ec.FieldMiddleware(ctx, nil, func(ctx context.Context) (interface{}, error) {
2997		return ec.resolvers.Mutation().AddComment(ctx, args["repoRef"].(*string), args["prefix"].(string), args["message"].(string), args["files"].([]git.Hash))
2998	})
2999	if resTmp == nil {
3000		if !ec.HasError(rctx) {
3001			ec.Errorf(ctx, "must not be null")
3002		}
3003		return graphql.Null
3004	}
3005	res := resTmp.(bug.Snapshot)
3006	rctx.Result = res
3007
3008	return ec._Bug(ctx, field.Selections, &res)
3009}
3010
3011// nolint: vetshadow
3012func (ec *executionContext) _Mutation_changeLabels(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
3013	rawArgs := field.ArgumentMap(ec.Variables)
3014	args, err := field_Mutation_changeLabels_args(rawArgs)
3015	if err != nil {
3016		ec.Error(ctx, err)
3017		return graphql.Null
3018	}
3019	rctx := &graphql.ResolverContext{
3020		Object: "Mutation",
3021		Args:   args,
3022		Field:  field,
3023	}
3024	ctx = graphql.WithResolverContext(ctx, rctx)
3025	resTmp := ec.FieldMiddleware(ctx, nil, func(ctx context.Context) (interface{}, error) {
3026		return ec.resolvers.Mutation().ChangeLabels(ctx, args["repoRef"].(*string), args["prefix"].(string), args["added"].([]string), args["removed"].([]string))
3027	})
3028	if resTmp == nil {
3029		if !ec.HasError(rctx) {
3030			ec.Errorf(ctx, "must not be null")
3031		}
3032		return graphql.Null
3033	}
3034	res := resTmp.(bug.Snapshot)
3035	rctx.Result = res
3036
3037	return ec._Bug(ctx, field.Selections, &res)
3038}
3039
3040// nolint: vetshadow
3041func (ec *executionContext) _Mutation_open(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
3042	rawArgs := field.ArgumentMap(ec.Variables)
3043	args, err := field_Mutation_open_args(rawArgs)
3044	if err != nil {
3045		ec.Error(ctx, err)
3046		return graphql.Null
3047	}
3048	rctx := &graphql.ResolverContext{
3049		Object: "Mutation",
3050		Args:   args,
3051		Field:  field,
3052	}
3053	ctx = graphql.WithResolverContext(ctx, rctx)
3054	resTmp := ec.FieldMiddleware(ctx, nil, func(ctx context.Context) (interface{}, error) {
3055		return ec.resolvers.Mutation().Open(ctx, args["repoRef"].(*string), args["prefix"].(string))
3056	})
3057	if resTmp == nil {
3058		if !ec.HasError(rctx) {
3059			ec.Errorf(ctx, "must not be null")
3060		}
3061		return graphql.Null
3062	}
3063	res := resTmp.(bug.Snapshot)
3064	rctx.Result = res
3065
3066	return ec._Bug(ctx, field.Selections, &res)
3067}
3068
3069// nolint: vetshadow
3070func (ec *executionContext) _Mutation_close(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
3071	rawArgs := field.ArgumentMap(ec.Variables)
3072	args, err := field_Mutation_close_args(rawArgs)
3073	if err != nil {
3074		ec.Error(ctx, err)
3075		return graphql.Null
3076	}
3077	rctx := &graphql.ResolverContext{
3078		Object: "Mutation",
3079		Args:   args,
3080		Field:  field,
3081	}
3082	ctx = graphql.WithResolverContext(ctx, rctx)
3083	resTmp := ec.FieldMiddleware(ctx, nil, func(ctx context.Context) (interface{}, error) {
3084		return ec.resolvers.Mutation().Close(ctx, args["repoRef"].(*string), args["prefix"].(string))
3085	})
3086	if resTmp == nil {
3087		if !ec.HasError(rctx) {
3088			ec.Errorf(ctx, "must not be null")
3089		}
3090		return graphql.Null
3091	}
3092	res := resTmp.(bug.Snapshot)
3093	rctx.Result = res
3094
3095	return ec._Bug(ctx, field.Selections, &res)
3096}
3097
3098// nolint: vetshadow
3099func (ec *executionContext) _Mutation_setTitle(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
3100	rawArgs := field.ArgumentMap(ec.Variables)
3101	args, err := field_Mutation_setTitle_args(rawArgs)
3102	if err != nil {
3103		ec.Error(ctx, err)
3104		return graphql.Null
3105	}
3106	rctx := &graphql.ResolverContext{
3107		Object: "Mutation",
3108		Args:   args,
3109		Field:  field,
3110	}
3111	ctx = graphql.WithResolverContext(ctx, rctx)
3112	resTmp := ec.FieldMiddleware(ctx, nil, func(ctx context.Context) (interface{}, error) {
3113		return ec.resolvers.Mutation().SetTitle(ctx, args["repoRef"].(*string), args["prefix"].(string), args["title"].(string))
3114	})
3115	if resTmp == nil {
3116		if !ec.HasError(rctx) {
3117			ec.Errorf(ctx, "must not be null")
3118		}
3119		return graphql.Null
3120	}
3121	res := resTmp.(bug.Snapshot)
3122	rctx.Result = res
3123
3124	return ec._Bug(ctx, field.Selections, &res)
3125}
3126
3127// nolint: vetshadow
3128func (ec *executionContext) _Mutation_commit(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
3129	rawArgs := field.ArgumentMap(ec.Variables)
3130	args, err := field_Mutation_commit_args(rawArgs)
3131	if err != nil {
3132		ec.Error(ctx, err)
3133		return graphql.Null
3134	}
3135	rctx := &graphql.ResolverContext{
3136		Object: "Mutation",
3137		Args:   args,
3138		Field:  field,
3139	}
3140	ctx = graphql.WithResolverContext(ctx, rctx)
3141	resTmp := ec.FieldMiddleware(ctx, nil, func(ctx context.Context) (interface{}, error) {
3142		return ec.resolvers.Mutation().Commit(ctx, args["repoRef"].(*string), args["prefix"].(string))
3143	})
3144	if resTmp == nil {
3145		if !ec.HasError(rctx) {
3146			ec.Errorf(ctx, "must not be null")
3147		}
3148		return graphql.Null
3149	}
3150	res := resTmp.(bug.Snapshot)
3151	rctx.Result = res
3152
3153	return ec._Bug(ctx, field.Selections, &res)
3154}
3155
3156var operationConnectionImplementors = []string{"OperationConnection"}
3157
3158// nolint: gocyclo, errcheck, gas, goconst
3159func (ec *executionContext) _OperationConnection(ctx context.Context, sel ast.SelectionSet, obj *models.OperationConnection) graphql.Marshaler {
3160	fields := graphql.CollectFields(ctx, sel, operationConnectionImplementors)
3161
3162	out := graphql.NewOrderedMap(len(fields))
3163	invalid := false
3164	for i, field := range fields {
3165		out.Keys[i] = field.Alias
3166
3167		switch field.Name {
3168		case "__typename":
3169			out.Values[i] = graphql.MarshalString("OperationConnection")
3170		case "edges":
3171			out.Values[i] = ec._OperationConnection_edges(ctx, field, obj)
3172			if out.Values[i] == graphql.Null {
3173				invalid = true
3174			}
3175		case "nodes":
3176			out.Values[i] = ec._OperationConnection_nodes(ctx, field, obj)
3177			if out.Values[i] == graphql.Null {
3178				invalid = true
3179			}
3180		case "pageInfo":
3181			out.Values[i] = ec._OperationConnection_pageInfo(ctx, field, obj)
3182			if out.Values[i] == graphql.Null {
3183				invalid = true
3184			}
3185		case "totalCount":
3186			out.Values[i] = ec._OperationConnection_totalCount(ctx, field, obj)
3187			if out.Values[i] == graphql.Null {
3188				invalid = true
3189			}
3190		default:
3191			panic("unknown field " + strconv.Quote(field.Name))
3192		}
3193	}
3194
3195	if invalid {
3196		return graphql.Null
3197	}
3198	return out
3199}
3200
3201// nolint: vetshadow
3202func (ec *executionContext) _OperationConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) graphql.Marshaler {
3203	rctx := &graphql.ResolverContext{
3204		Object: "OperationConnection",
3205		Args:   nil,
3206		Field:  field,
3207	}
3208	ctx = graphql.WithResolverContext(ctx, rctx)
3209	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
3210		return obj.Edges, nil
3211	})
3212	if resTmp == nil {
3213		if !ec.HasError(rctx) {
3214			ec.Errorf(ctx, "must not be null")
3215		}
3216		return graphql.Null
3217	}
3218	res := resTmp.([]models.OperationEdge)
3219	rctx.Result = res
3220
3221	arr1 := make(graphql.Array, len(res))
3222	var wg sync.WaitGroup
3223
3224	isLen1 := len(res) == 1
3225	if !isLen1 {
3226		wg.Add(len(res))
3227	}
3228
3229	for idx1 := range res {
3230		idx1 := idx1
3231		rctx := &graphql.ResolverContext{
3232			Index:  &idx1,
3233			Result: &res[idx1],
3234		}
3235		ctx := graphql.WithResolverContext(ctx, rctx)
3236		f := func(idx1 int) {
3237			if !isLen1 {
3238				defer wg.Done()
3239			}
3240			arr1[idx1] = func() graphql.Marshaler {
3241
3242				return ec._OperationEdge(ctx, field.Selections, &res[idx1])
3243			}()
3244		}
3245		if isLen1 {
3246			f(idx1)
3247		} else {
3248			go f(idx1)
3249		}
3250
3251	}
3252	wg.Wait()
3253	return arr1
3254}
3255
3256// nolint: vetshadow
3257func (ec *executionContext) _OperationConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) graphql.Marshaler {
3258	rctx := &graphql.ResolverContext{
3259		Object: "OperationConnection",
3260		Args:   nil,
3261		Field:  field,
3262	}
3263	ctx = graphql.WithResolverContext(ctx, rctx)
3264	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
3265		return obj.Nodes, nil
3266	})
3267	if resTmp == nil {
3268		if !ec.HasError(rctx) {
3269			ec.Errorf(ctx, "must not be null")
3270		}
3271		return graphql.Null
3272	}
3273	res := resTmp.([]bug.Operation)
3274	rctx.Result = res
3275
3276	arr1 := make(graphql.Array, len(res))
3277	var wg sync.WaitGroup
3278
3279	isLen1 := len(res) == 1
3280	if !isLen1 {
3281		wg.Add(len(res))
3282	}
3283
3284	for idx1 := range res {
3285		idx1 := idx1
3286		rctx := &graphql.ResolverContext{
3287			Index:  &idx1,
3288			Result: &res[idx1],
3289		}
3290		ctx := graphql.WithResolverContext(ctx, rctx)
3291		f := func(idx1 int) {
3292			if !isLen1 {
3293				defer wg.Done()
3294			}
3295			arr1[idx1] = func() graphql.Marshaler {
3296
3297				return ec._Operation(ctx, field.Selections, &res[idx1])
3298			}()
3299		}
3300		if isLen1 {
3301			f(idx1)
3302		} else {
3303			go f(idx1)
3304		}
3305
3306	}
3307	wg.Wait()
3308	return arr1
3309}
3310
3311// nolint: vetshadow
3312func (ec *executionContext) _OperationConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) graphql.Marshaler {
3313	rctx := &graphql.ResolverContext{
3314		Object: "OperationConnection",
3315		Args:   nil,
3316		Field:  field,
3317	}
3318	ctx = graphql.WithResolverContext(ctx, rctx)
3319	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
3320		return obj.PageInfo, nil
3321	})
3322	if resTmp == nil {
3323		if !ec.HasError(rctx) {
3324			ec.Errorf(ctx, "must not be null")
3325		}
3326		return graphql.Null
3327	}
3328	res := resTmp.(models.PageInfo)
3329	rctx.Result = res
3330
3331	return ec._PageInfo(ctx, field.Selections, &res)
3332}
3333
3334// nolint: vetshadow
3335func (ec *executionContext) _OperationConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) graphql.Marshaler {
3336	rctx := &graphql.ResolverContext{
3337		Object: "OperationConnection",
3338		Args:   nil,
3339		Field:  field,
3340	}
3341	ctx = graphql.WithResolverContext(ctx, rctx)
3342	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
3343		return obj.TotalCount, nil
3344	})
3345	if resTmp == nil {
3346		if !ec.HasError(rctx) {
3347			ec.Errorf(ctx, "must not be null")
3348		}
3349		return graphql.Null
3350	}
3351	res := resTmp.(int)
3352	rctx.Result = res
3353	return graphql.MarshalInt(res)
3354}
3355
3356var operationEdgeImplementors = []string{"OperationEdge"}
3357
3358// nolint: gocyclo, errcheck, gas, goconst
3359func (ec *executionContext) _OperationEdge(ctx context.Context, sel ast.SelectionSet, obj *models.OperationEdge) graphql.Marshaler {
3360	fields := graphql.CollectFields(ctx, sel, operationEdgeImplementors)
3361
3362	out := graphql.NewOrderedMap(len(fields))
3363	invalid := false
3364	for i, field := range fields {
3365		out.Keys[i] = field.Alias
3366
3367		switch field.Name {
3368		case "__typename":
3369			out.Values[i] = graphql.MarshalString("OperationEdge")
3370		case "cursor":
3371			out.Values[i] = ec._OperationEdge_cursor(ctx, field, obj)
3372			if out.Values[i] == graphql.Null {
3373				invalid = true
3374			}
3375		case "node":
3376			out.Values[i] = ec._OperationEdge_node(ctx, field, obj)
3377			if out.Values[i] == graphql.Null {
3378				invalid = true
3379			}
3380		default:
3381			panic("unknown field " + strconv.Quote(field.Name))
3382		}
3383	}
3384
3385	if invalid {
3386		return graphql.Null
3387	}
3388	return out
3389}
3390
3391// nolint: vetshadow
3392func (ec *executionContext) _OperationEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.OperationEdge) graphql.Marshaler {
3393	rctx := &graphql.ResolverContext{
3394		Object: "OperationEdge",
3395		Args:   nil,
3396		Field:  field,
3397	}
3398	ctx = graphql.WithResolverContext(ctx, rctx)
3399	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
3400		return obj.Cursor, nil
3401	})
3402	if resTmp == nil {
3403		if !ec.HasError(rctx) {
3404			ec.Errorf(ctx, "must not be null")
3405		}
3406		return graphql.Null
3407	}
3408	res := resTmp.(string)
3409	rctx.Result = res
3410	return graphql.MarshalString(res)
3411}
3412
3413// nolint: vetshadow
3414func (ec *executionContext) _OperationEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.OperationEdge) graphql.Marshaler {
3415	rctx := &graphql.ResolverContext{
3416		Object: "OperationEdge",
3417		Args:   nil,
3418		Field:  field,
3419	}
3420	ctx = graphql.WithResolverContext(ctx, rctx)
3421	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
3422		return obj.Node, nil
3423	})
3424	if resTmp == nil {
3425		if !ec.HasError(rctx) {
3426			ec.Errorf(ctx, "must not be null")
3427		}
3428		return graphql.Null
3429	}
3430	res := resTmp.(bug.Operation)
3431	rctx.Result = res
3432
3433	return ec._Operation(ctx, field.Selections, &res)
3434}
3435
3436var pageInfoImplementors = []string{"PageInfo"}
3437
3438// nolint: gocyclo, errcheck, gas, goconst
3439func (ec *executionContext) _PageInfo(ctx context.Context, sel ast.SelectionSet, obj *models.PageInfo) graphql.Marshaler {
3440	fields := graphql.CollectFields(ctx, sel, pageInfoImplementors)
3441
3442	out := graphql.NewOrderedMap(len(fields))
3443	invalid := false
3444	for i, field := range fields {
3445		out.Keys[i] = field.Alias
3446
3447		switch field.Name {
3448		case "__typename":
3449			out.Values[i] = graphql.MarshalString("PageInfo")
3450		case "hasNextPage":
3451			out.Values[i] = ec._PageInfo_hasNextPage(ctx, field, obj)
3452			if out.Values[i] == graphql.Null {
3453				invalid = true
3454			}
3455		case "hasPreviousPage":
3456			out.Values[i] = ec._PageInfo_hasPreviousPage(ctx, field, obj)
3457			if out.Values[i] == graphql.Null {
3458				invalid = true
3459			}
3460		case "startCursor":
3461			out.Values[i] = ec._PageInfo_startCursor(ctx, field, obj)
3462			if out.Values[i] == graphql.Null {
3463				invalid = true
3464			}
3465		case "endCursor":
3466			out.Values[i] = ec._PageInfo_endCursor(ctx, field, obj)
3467			if out.Values[i] == graphql.Null {
3468				invalid = true
3469			}
3470		default:
3471			panic("unknown field " + strconv.Quote(field.Name))
3472		}
3473	}
3474
3475	if invalid {
3476		return graphql.Null
3477	}
3478	return out
3479}
3480
3481// nolint: vetshadow
3482func (ec *executionContext) _PageInfo_hasNextPage(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) graphql.Marshaler {
3483	rctx := &graphql.ResolverContext{
3484		Object: "PageInfo",
3485		Args:   nil,
3486		Field:  field,
3487	}
3488	ctx = graphql.WithResolverContext(ctx, rctx)
3489	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
3490		return obj.HasNextPage, nil
3491	})
3492	if resTmp == nil {
3493		if !ec.HasError(rctx) {
3494			ec.Errorf(ctx, "must not be null")
3495		}
3496		return graphql.Null
3497	}
3498	res := resTmp.(bool)
3499	rctx.Result = res
3500	return graphql.MarshalBoolean(res)
3501}
3502
3503// nolint: vetshadow
3504func (ec *executionContext) _PageInfo_hasPreviousPage(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) graphql.Marshaler {
3505	rctx := &graphql.ResolverContext{
3506		Object: "PageInfo",
3507		Args:   nil,
3508		Field:  field,
3509	}
3510	ctx = graphql.WithResolverContext(ctx, rctx)
3511	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
3512		return obj.HasPreviousPage, nil
3513	})
3514	if resTmp == nil {
3515		if !ec.HasError(rctx) {
3516			ec.Errorf(ctx, "must not be null")
3517		}
3518		return graphql.Null
3519	}
3520	res := resTmp.(bool)
3521	rctx.Result = res
3522	return graphql.MarshalBoolean(res)
3523}
3524
3525// nolint: vetshadow
3526func (ec *executionContext) _PageInfo_startCursor(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) graphql.Marshaler {
3527	rctx := &graphql.ResolverContext{
3528		Object: "PageInfo",
3529		Args:   nil,
3530		Field:  field,
3531	}
3532	ctx = graphql.WithResolverContext(ctx, rctx)
3533	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
3534		return obj.StartCursor, nil
3535	})
3536	if resTmp == nil {
3537		if !ec.HasError(rctx) {
3538			ec.Errorf(ctx, "must not be null")
3539		}
3540		return graphql.Null
3541	}
3542	res := resTmp.(string)
3543	rctx.Result = res
3544	return graphql.MarshalString(res)
3545}
3546
3547// nolint: vetshadow
3548func (ec *executionContext) _PageInfo_endCursor(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) graphql.Marshaler {
3549	rctx := &graphql.ResolverContext{
3550		Object: "PageInfo",
3551		Args:   nil,
3552		Field:  field,
3553	}
3554	ctx = graphql.WithResolverContext(ctx, rctx)
3555	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
3556		return obj.EndCursor, nil
3557	})
3558	if resTmp == nil {
3559		if !ec.HasError(rctx) {
3560			ec.Errorf(ctx, "must not be null")
3561		}
3562		return graphql.Null
3563	}
3564	res := resTmp.(string)
3565	rctx.Result = res
3566	return graphql.MarshalString(res)
3567}
3568
3569var personImplementors = []string{"Person"}
3570
3571// nolint: gocyclo, errcheck, gas, goconst
3572func (ec *executionContext) _Person(ctx context.Context, sel ast.SelectionSet, obj *bug.Person) graphql.Marshaler {
3573	fields := graphql.CollectFields(ctx, sel, personImplementors)
3574
3575	out := graphql.NewOrderedMap(len(fields))
3576	invalid := false
3577	for i, field := range fields {
3578		out.Keys[i] = field.Alias
3579
3580		switch field.Name {
3581		case "__typename":
3582			out.Values[i] = graphql.MarshalString("Person")
3583		case "email":
3584			out.Values[i] = ec._Person_email(ctx, field, obj)
3585		case "name":
3586			out.Values[i] = ec._Person_name(ctx, field, obj)
3587		default:
3588			panic("unknown field " + strconv.Quote(field.Name))
3589		}
3590	}
3591
3592	if invalid {
3593		return graphql.Null
3594	}
3595	return out
3596}
3597
3598// nolint: vetshadow
3599func (ec *executionContext) _Person_email(ctx context.Context, field graphql.CollectedField, obj *bug.Person) graphql.Marshaler {
3600	rctx := &graphql.ResolverContext{
3601		Object: "Person",
3602		Args:   nil,
3603		Field:  field,
3604	}
3605	ctx = graphql.WithResolverContext(ctx, rctx)
3606	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
3607		return obj.Email, nil
3608	})
3609	if resTmp == nil {
3610		return graphql.Null
3611	}
3612	res := resTmp.(string)
3613	rctx.Result = res
3614	return graphql.MarshalString(res)
3615}
3616
3617// nolint: vetshadow
3618func (ec *executionContext) _Person_name(ctx context.Context, field graphql.CollectedField, obj *bug.Person) graphql.Marshaler {
3619	rctx := &graphql.ResolverContext{
3620		Object: "Person",
3621		Args:   nil,
3622		Field:  field,
3623	}
3624	ctx = graphql.WithResolverContext(ctx, rctx)
3625	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
3626		return obj.Name, nil
3627	})
3628	if resTmp == nil {
3629		return graphql.Null
3630	}
3631	res := resTmp.(string)
3632	rctx.Result = res
3633	return graphql.MarshalString(res)
3634}
3635
3636var queryImplementors = []string{"Query"}
3637
3638// nolint: gocyclo, errcheck, gas, goconst
3639func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
3640	fields := graphql.CollectFields(ctx, sel, queryImplementors)
3641
3642	ctx = graphql.WithResolverContext(ctx, &graphql.ResolverContext{
3643		Object: "Query",
3644	})
3645
3646	var wg sync.WaitGroup
3647	out := graphql.NewOrderedMap(len(fields))
3648	invalid := false
3649	for i, field := range fields {
3650		out.Keys[i] = field.Alias
3651
3652		switch field.Name {
3653		case "__typename":
3654			out.Values[i] = graphql.MarshalString("Query")
3655		case "defaultRepository":
3656			wg.Add(1)
3657			go func(i int, field graphql.CollectedField) {
3658				out.Values[i] = ec._Query_defaultRepository(ctx, field)
3659				wg.Done()
3660			}(i, field)
3661		case "repository":
3662			wg.Add(1)
3663			go func(i int, field graphql.CollectedField) {
3664				out.Values[i] = ec._Query_repository(ctx, field)
3665				wg.Done()
3666			}(i, field)
3667		case "__type":
3668			out.Values[i] = ec._Query___type(ctx, field)
3669		case "__schema":
3670			out.Values[i] = ec._Query___schema(ctx, field)
3671		default:
3672			panic("unknown field " + strconv.Quote(field.Name))
3673		}
3674	}
3675	wg.Wait()
3676	if invalid {
3677		return graphql.Null
3678	}
3679	return out
3680}
3681
3682// nolint: vetshadow
3683func (ec *executionContext) _Query_defaultRepository(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
3684	rctx := &graphql.ResolverContext{
3685		Object: "Query",
3686		Args:   nil,
3687		Field:  field,
3688	}
3689	ctx = graphql.WithResolverContext(ctx, rctx)
3690	resTmp := ec.FieldMiddleware(ctx, nil, func(ctx context.Context) (interface{}, error) {
3691		return ec.resolvers.Query().DefaultRepository(ctx)
3692	})
3693	if resTmp == nil {
3694		return graphql.Null
3695	}
3696	res := resTmp.(*models.Repository)
3697	rctx.Result = res
3698
3699	if res == nil {
3700		return graphql.Null
3701	}
3702
3703	return ec._Repository(ctx, field.Selections, res)
3704}
3705
3706// nolint: vetshadow
3707func (ec *executionContext) _Query_repository(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
3708	rawArgs := field.ArgumentMap(ec.Variables)
3709	args, err := field_Query_repository_args(rawArgs)
3710	if err != nil {
3711		ec.Error(ctx, err)
3712		return graphql.Null
3713	}
3714	rctx := &graphql.ResolverContext{
3715		Object: "Query",
3716		Args:   args,
3717		Field:  field,
3718	}
3719	ctx = graphql.WithResolverContext(ctx, rctx)
3720	resTmp := ec.FieldMiddleware(ctx, nil, func(ctx context.Context) (interface{}, error) {
3721		return ec.resolvers.Query().Repository(ctx, args["id"].(string))
3722	})
3723	if resTmp == nil {
3724		return graphql.Null
3725	}
3726	res := resTmp.(*models.Repository)
3727	rctx.Result = res
3728
3729	if res == nil {
3730		return graphql.Null
3731	}
3732
3733	return ec._Repository(ctx, field.Selections, res)
3734}
3735
3736// nolint: vetshadow
3737func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
3738	rawArgs := field.ArgumentMap(ec.Variables)
3739	args, err := field_Query___type_args(rawArgs)
3740	if err != nil {
3741		ec.Error(ctx, err)
3742		return graphql.Null
3743	}
3744	rctx := &graphql.ResolverContext{
3745		Object: "Query",
3746		Args:   args,
3747		Field:  field,
3748	}
3749	ctx = graphql.WithResolverContext(ctx, rctx)
3750	resTmp := ec.FieldMiddleware(ctx, nil, func(ctx context.Context) (interface{}, error) {
3751		return ec.introspectType(args["name"].(string)), nil
3752	})
3753	if resTmp == nil {
3754		return graphql.Null
3755	}
3756	res := resTmp.(*introspection.Type)
3757	rctx.Result = res
3758
3759	if res == nil {
3760		return graphql.Null
3761	}
3762
3763	return ec.___Type(ctx, field.Selections, res)
3764}
3765
3766// nolint: vetshadow
3767func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
3768	rctx := &graphql.ResolverContext{
3769		Object: "Query",
3770		Args:   nil,
3771		Field:  field,
3772	}
3773	ctx = graphql.WithResolverContext(ctx, rctx)
3774	resTmp := ec.FieldMiddleware(ctx, nil, func(ctx context.Context) (interface{}, error) {
3775		return ec.introspectSchema(), nil
3776	})
3777	if resTmp == nil {
3778		return graphql.Null
3779	}
3780	res := resTmp.(*introspection.Schema)
3781	rctx.Result = res
3782
3783	if res == nil {
3784		return graphql.Null
3785	}
3786
3787	return ec.___Schema(ctx, field.Selections, res)
3788}
3789
3790var repositoryImplementors = []string{"Repository"}
3791
3792// nolint: gocyclo, errcheck, gas, goconst
3793func (ec *executionContext) _Repository(ctx context.Context, sel ast.SelectionSet, obj *models.Repository) graphql.Marshaler {
3794	fields := graphql.CollectFields(ctx, sel, repositoryImplementors)
3795
3796	var wg sync.WaitGroup
3797	out := graphql.NewOrderedMap(len(fields))
3798	invalid := false
3799	for i, field := range fields {
3800		out.Keys[i] = field.Alias
3801
3802		switch field.Name {
3803		case "__typename":
3804			out.Values[i] = graphql.MarshalString("Repository")
3805		case "allBugs":
3806			wg.Add(1)
3807			go func(i int, field graphql.CollectedField) {
3808				out.Values[i] = ec._Repository_allBugs(ctx, field, obj)
3809				if out.Values[i] == graphql.Null {
3810					invalid = true
3811				}
3812				wg.Done()
3813			}(i, field)
3814		case "bug":
3815			wg.Add(1)
3816			go func(i int, field graphql.CollectedField) {
3817				out.Values[i] = ec._Repository_bug(ctx, field, obj)
3818				wg.Done()
3819			}(i, field)
3820		default:
3821			panic("unknown field " + strconv.Quote(field.Name))
3822		}
3823	}
3824	wg.Wait()
3825	if invalid {
3826		return graphql.Null
3827	}
3828	return out
3829}
3830
3831// nolint: vetshadow
3832func (ec *executionContext) _Repository_allBugs(ctx context.Context, field graphql.CollectedField, obj *models.Repository) graphql.Marshaler {
3833	rawArgs := field.ArgumentMap(ec.Variables)
3834	args, err := field_Repository_allBugs_args(rawArgs)
3835	if err != nil {
3836		ec.Error(ctx, err)
3837		return graphql.Null
3838	}
3839	rctx := &graphql.ResolverContext{
3840		Object: "Repository",
3841		Args:   args,
3842		Field:  field,
3843	}
3844	ctx = graphql.WithResolverContext(ctx, rctx)
3845	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
3846		return ec.resolvers.Repository().AllBugs(ctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int), args["query"].(*string))
3847	})
3848	if resTmp == nil {
3849		if !ec.HasError(rctx) {
3850			ec.Errorf(ctx, "must not be null")
3851		}
3852		return graphql.Null
3853	}
3854	res := resTmp.(models.BugConnection)
3855	rctx.Result = res
3856
3857	return ec._BugConnection(ctx, field.Selections, &res)
3858}
3859
3860// nolint: vetshadow
3861func (ec *executionContext) _Repository_bug(ctx context.Context, field graphql.CollectedField, obj *models.Repository) graphql.Marshaler {
3862	rawArgs := field.ArgumentMap(ec.Variables)
3863	args, err := field_Repository_bug_args(rawArgs)
3864	if err != nil {
3865		ec.Error(ctx, err)
3866		return graphql.Null
3867	}
3868	rctx := &graphql.ResolverContext{
3869		Object: "Repository",
3870		Args:   args,
3871		Field:  field,
3872	}
3873	ctx = graphql.WithResolverContext(ctx, rctx)
3874	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
3875		return ec.resolvers.Repository().Bug(ctx, obj, args["prefix"].(string))
3876	})
3877	if resTmp == nil {
3878		return graphql.Null
3879	}
3880	res := resTmp.(*bug.Snapshot)
3881	rctx.Result = res
3882
3883	if res == nil {
3884		return graphql.Null
3885	}
3886
3887	return ec._Bug(ctx, field.Selections, res)
3888}
3889
3890var setStatusOperationImplementors = []string{"SetStatusOperation", "Operation", "Authored"}
3891
3892// nolint: gocyclo, errcheck, gas, goconst
3893func (ec *executionContext) _SetStatusOperation(ctx context.Context, sel ast.SelectionSet, obj *operations.SetStatusOperation) graphql.Marshaler {
3894	fields := graphql.CollectFields(ctx, sel, setStatusOperationImplementors)
3895
3896	var wg sync.WaitGroup
3897	out := graphql.NewOrderedMap(len(fields))
3898	invalid := false
3899	for i, field := range fields {
3900		out.Keys[i] = field.Alias
3901
3902		switch field.Name {
3903		case "__typename":
3904			out.Values[i] = graphql.MarshalString("SetStatusOperation")
3905		case "author":
3906			out.Values[i] = ec._SetStatusOperation_author(ctx, field, obj)
3907			if out.Values[i] == graphql.Null {
3908				invalid = true
3909			}
3910		case "date":
3911			wg.Add(1)
3912			go func(i int, field graphql.CollectedField) {
3913				out.Values[i] = ec._SetStatusOperation_date(ctx, field, obj)
3914				if out.Values[i] == graphql.Null {
3915					invalid = true
3916				}
3917				wg.Done()
3918			}(i, field)
3919		case "status":
3920			wg.Add(1)
3921			go func(i int, field graphql.CollectedField) {
3922				out.Values[i] = ec._SetStatusOperation_status(ctx, field, obj)
3923				if out.Values[i] == graphql.Null {
3924					invalid = true
3925				}
3926				wg.Done()
3927			}(i, field)
3928		default:
3929			panic("unknown field " + strconv.Quote(field.Name))
3930		}
3931	}
3932	wg.Wait()
3933	if invalid {
3934		return graphql.Null
3935	}
3936	return out
3937}
3938
3939// nolint: vetshadow
3940func (ec *executionContext) _SetStatusOperation_author(ctx context.Context, field graphql.CollectedField, obj *operations.SetStatusOperation) graphql.Marshaler {
3941	rctx := &graphql.ResolverContext{
3942		Object: "SetStatusOperation",
3943		Args:   nil,
3944		Field:  field,
3945	}
3946	ctx = graphql.WithResolverContext(ctx, rctx)
3947	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
3948		return obj.Author, nil
3949	})
3950	if resTmp == nil {
3951		if !ec.HasError(rctx) {
3952			ec.Errorf(ctx, "must not be null")
3953		}
3954		return graphql.Null
3955	}
3956	res := resTmp.(bug.Person)
3957	rctx.Result = res
3958
3959	return ec._Person(ctx, field.Selections, &res)
3960}
3961
3962// nolint: vetshadow
3963func (ec *executionContext) _SetStatusOperation_date(ctx context.Context, field graphql.CollectedField, obj *operations.SetStatusOperation) graphql.Marshaler {
3964	rctx := &graphql.ResolverContext{
3965		Object: "SetStatusOperation",
3966		Args:   nil,
3967		Field:  field,
3968	}
3969	ctx = graphql.WithResolverContext(ctx, rctx)
3970	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
3971		return ec.resolvers.SetStatusOperation().Date(ctx, obj)
3972	})
3973	if resTmp == nil {
3974		if !ec.HasError(rctx) {
3975			ec.Errorf(ctx, "must not be null")
3976		}
3977		return graphql.Null
3978	}
3979	res := resTmp.(time.Time)
3980	rctx.Result = res
3981	return graphql.MarshalTime(res)
3982}
3983
3984// nolint: vetshadow
3985func (ec *executionContext) _SetStatusOperation_status(ctx context.Context, field graphql.CollectedField, obj *operations.SetStatusOperation) graphql.Marshaler {
3986	rctx := &graphql.ResolverContext{
3987		Object: "SetStatusOperation",
3988		Args:   nil,
3989		Field:  field,
3990	}
3991	ctx = graphql.WithResolverContext(ctx, rctx)
3992	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
3993		return ec.resolvers.SetStatusOperation().Status(ctx, obj)
3994	})
3995	if resTmp == nil {
3996		if !ec.HasError(rctx) {
3997			ec.Errorf(ctx, "must not be null")
3998		}
3999		return graphql.Null
4000	}
4001	res := resTmp.(models.Status)
4002	rctx.Result = res
4003	return res
4004}
4005
4006var setTitleOperationImplementors = []string{"SetTitleOperation", "Operation", "Authored"}
4007
4008// nolint: gocyclo, errcheck, gas, goconst
4009func (ec *executionContext) _SetTitleOperation(ctx context.Context, sel ast.SelectionSet, obj *operations.SetTitleOperation) graphql.Marshaler {
4010	fields := graphql.CollectFields(ctx, sel, setTitleOperationImplementors)
4011
4012	var wg sync.WaitGroup
4013	out := graphql.NewOrderedMap(len(fields))
4014	invalid := false
4015	for i, field := range fields {
4016		out.Keys[i] = field.Alias
4017
4018		switch field.Name {
4019		case "__typename":
4020			out.Values[i] = graphql.MarshalString("SetTitleOperation")
4021		case "author":
4022			out.Values[i] = ec._SetTitleOperation_author(ctx, field, obj)
4023			if out.Values[i] == graphql.Null {
4024				invalid = true
4025			}
4026		case "date":
4027			wg.Add(1)
4028			go func(i int, field graphql.CollectedField) {
4029				out.Values[i] = ec._SetTitleOperation_date(ctx, field, obj)
4030				if out.Values[i] == graphql.Null {
4031					invalid = true
4032				}
4033				wg.Done()
4034			}(i, field)
4035		case "title":
4036			out.Values[i] = ec._SetTitleOperation_title(ctx, field, obj)
4037			if out.Values[i] == graphql.Null {
4038				invalid = true
4039			}
4040		case "was":
4041			out.Values[i] = ec._SetTitleOperation_was(ctx, field, obj)
4042			if out.Values[i] == graphql.Null {
4043				invalid = true
4044			}
4045		default:
4046			panic("unknown field " + strconv.Quote(field.Name))
4047		}
4048	}
4049	wg.Wait()
4050	if invalid {
4051		return graphql.Null
4052	}
4053	return out
4054}
4055
4056// nolint: vetshadow
4057func (ec *executionContext) _SetTitleOperation_author(ctx context.Context, field graphql.CollectedField, obj *operations.SetTitleOperation) graphql.Marshaler {
4058	rctx := &graphql.ResolverContext{
4059		Object: "SetTitleOperation",
4060		Args:   nil,
4061		Field:  field,
4062	}
4063	ctx = graphql.WithResolverContext(ctx, rctx)
4064	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
4065		return obj.Author, nil
4066	})
4067	if resTmp == nil {
4068		if !ec.HasError(rctx) {
4069			ec.Errorf(ctx, "must not be null")
4070		}
4071		return graphql.Null
4072	}
4073	res := resTmp.(bug.Person)
4074	rctx.Result = res
4075
4076	return ec._Person(ctx, field.Selections, &res)
4077}
4078
4079// nolint: vetshadow
4080func (ec *executionContext) _SetTitleOperation_date(ctx context.Context, field graphql.CollectedField, obj *operations.SetTitleOperation) graphql.Marshaler {
4081	rctx := &graphql.ResolverContext{
4082		Object: "SetTitleOperation",
4083		Args:   nil,
4084		Field:  field,
4085	}
4086	ctx = graphql.WithResolverContext(ctx, rctx)
4087	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
4088		return ec.resolvers.SetTitleOperation().Date(ctx, obj)
4089	})
4090	if resTmp == nil {
4091		if !ec.HasError(rctx) {
4092			ec.Errorf(ctx, "must not be null")
4093		}
4094		return graphql.Null
4095	}
4096	res := resTmp.(time.Time)
4097	rctx.Result = res
4098	return graphql.MarshalTime(res)
4099}
4100
4101// nolint: vetshadow
4102func (ec *executionContext) _SetTitleOperation_title(ctx context.Context, field graphql.CollectedField, obj *operations.SetTitleOperation) graphql.Marshaler {
4103	rctx := &graphql.ResolverContext{
4104		Object: "SetTitleOperation",
4105		Args:   nil,
4106		Field:  field,
4107	}
4108	ctx = graphql.WithResolverContext(ctx, rctx)
4109	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
4110		return obj.Title, nil
4111	})
4112	if resTmp == nil {
4113		if !ec.HasError(rctx) {
4114			ec.Errorf(ctx, "must not be null")
4115		}
4116		return graphql.Null
4117	}
4118	res := resTmp.(string)
4119	rctx.Result = res
4120	return graphql.MarshalString(res)
4121}
4122
4123// nolint: vetshadow
4124func (ec *executionContext) _SetTitleOperation_was(ctx context.Context, field graphql.CollectedField, obj *operations.SetTitleOperation) graphql.Marshaler {
4125	rctx := &graphql.ResolverContext{
4126		Object: "SetTitleOperation",
4127		Args:   nil,
4128		Field:  field,
4129	}
4130	ctx = graphql.WithResolverContext(ctx, rctx)
4131	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
4132		return obj.Was, nil
4133	})
4134	if resTmp == nil {
4135		if !ec.HasError(rctx) {
4136			ec.Errorf(ctx, "must not be null")
4137		}
4138		return graphql.Null
4139	}
4140	res := resTmp.(string)
4141	rctx.Result = res
4142	return graphql.MarshalString(res)
4143}
4144
4145var __DirectiveImplementors = []string{"__Directive"}
4146
4147// nolint: gocyclo, errcheck, gas, goconst
4148func (ec *executionContext) ___Directive(ctx context.Context, sel ast.SelectionSet, obj *introspection.Directive) graphql.Marshaler {
4149	fields := graphql.CollectFields(ctx, sel, __DirectiveImplementors)
4150
4151	out := graphql.NewOrderedMap(len(fields))
4152	invalid := false
4153	for i, field := range fields {
4154		out.Keys[i] = field.Alias
4155
4156		switch field.Name {
4157		case "__typename":
4158			out.Values[i] = graphql.MarshalString("__Directive")
4159		case "name":
4160			out.Values[i] = ec.___Directive_name(ctx, field, obj)
4161			if out.Values[i] == graphql.Null {
4162				invalid = true
4163			}
4164		case "description":
4165			out.Values[i] = ec.___Directive_description(ctx, field, obj)
4166		case "locations":
4167			out.Values[i] = ec.___Directive_locations(ctx, field, obj)
4168			if out.Values[i] == graphql.Null {
4169				invalid = true
4170			}
4171		case "args":
4172			out.Values[i] = ec.___Directive_args(ctx, field, obj)
4173			if out.Values[i] == graphql.Null {
4174				invalid = true
4175			}
4176		default:
4177			panic("unknown field " + strconv.Quote(field.Name))
4178		}
4179	}
4180
4181	if invalid {
4182		return graphql.Null
4183	}
4184	return out
4185}
4186
4187// nolint: vetshadow
4188func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) graphql.Marshaler {
4189	rctx := &graphql.ResolverContext{
4190		Object: "__Directive",
4191		Args:   nil,
4192		Field:  field,
4193	}
4194	ctx = graphql.WithResolverContext(ctx, rctx)
4195	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
4196		return obj.Name, nil
4197	})
4198	if resTmp == nil {
4199		if !ec.HasError(rctx) {
4200			ec.Errorf(ctx, "must not be null")
4201		}
4202		return graphql.Null
4203	}
4204	res := resTmp.(string)
4205	rctx.Result = res
4206	return graphql.MarshalString(res)
4207}
4208
4209// nolint: vetshadow
4210func (ec *executionContext) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) graphql.Marshaler {
4211	rctx := &graphql.ResolverContext{
4212		Object: "__Directive",
4213		Args:   nil,
4214		Field:  field,
4215	}
4216	ctx = graphql.WithResolverContext(ctx, rctx)
4217	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
4218		return obj.Description, nil
4219	})
4220	if resTmp == nil {
4221		return graphql.Null
4222	}
4223	res := resTmp.(string)
4224	rctx.Result = res
4225	return graphql.MarshalString(res)
4226}
4227
4228// nolint: vetshadow
4229func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) graphql.Marshaler {
4230	rctx := &graphql.ResolverContext{
4231		Object: "__Directive",
4232		Args:   nil,
4233		Field:  field,
4234	}
4235	ctx = graphql.WithResolverContext(ctx, rctx)
4236	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
4237		return obj.Locations, nil
4238	})
4239	if resTmp == nil {
4240		if !ec.HasError(rctx) {
4241			ec.Errorf(ctx, "must not be null")
4242		}
4243		return graphql.Null
4244	}
4245	res := resTmp.([]string)
4246	rctx.Result = res
4247
4248	arr1 := make(graphql.Array, len(res))
4249
4250	for idx1 := range res {
4251		arr1[idx1] = func() graphql.Marshaler {
4252			return graphql.MarshalString(res[idx1])
4253		}()
4254	}
4255
4256	return arr1
4257}
4258
4259// nolint: vetshadow
4260func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) graphql.Marshaler {
4261	rctx := &graphql.ResolverContext{
4262		Object: "__Directive",
4263		Args:   nil,
4264		Field:  field,
4265	}
4266	ctx = graphql.WithResolverContext(ctx, rctx)
4267	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
4268		return obj.Args, nil
4269	})
4270	if resTmp == nil {
4271		if !ec.HasError(rctx) {
4272			ec.Errorf(ctx, "must not be null")
4273		}
4274		return graphql.Null
4275	}
4276	res := resTmp.([]introspection.InputValue)
4277	rctx.Result = res
4278
4279	arr1 := make(graphql.Array, len(res))
4280	var wg sync.WaitGroup
4281
4282	isLen1 := len(res) == 1
4283	if !isLen1 {
4284		wg.Add(len(res))
4285	}
4286
4287	for idx1 := range res {
4288		idx1 := idx1
4289		rctx := &graphql.ResolverContext{
4290			Index:  &idx1,
4291			Result: &res[idx1],
4292		}
4293		ctx := graphql.WithResolverContext(ctx, rctx)
4294		f := func(idx1 int) {
4295			if !isLen1 {
4296				defer wg.Done()
4297			}
4298			arr1[idx1] = func() graphql.Marshaler {
4299
4300				return ec.___InputValue(ctx, field.Selections, &res[idx1])
4301			}()
4302		}
4303		if isLen1 {
4304			f(idx1)
4305		} else {
4306			go f(idx1)
4307		}
4308
4309	}
4310	wg.Wait()
4311	return arr1
4312}
4313
4314var __EnumValueImplementors = []string{"__EnumValue"}
4315
4316// nolint: gocyclo, errcheck, gas, goconst
4317func (ec *executionContext) ___EnumValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.EnumValue) graphql.Marshaler {
4318	fields := graphql.CollectFields(ctx, sel, __EnumValueImplementors)
4319
4320	out := graphql.NewOrderedMap(len(fields))
4321	invalid := false
4322	for i, field := range fields {
4323		out.Keys[i] = field.Alias
4324
4325		switch field.Name {
4326		case "__typename":
4327			out.Values[i] = graphql.MarshalString("__EnumValue")
4328		case "name":
4329			out.Values[i] = ec.___EnumValue_name(ctx, field, obj)
4330			if out.Values[i] == graphql.Null {
4331				invalid = true
4332			}
4333		case "description":
4334			out.Values[i] = ec.___EnumValue_description(ctx, field, obj)
4335		case "isDeprecated":
4336			out.Values[i] = ec.___EnumValue_isDeprecated(ctx, field, obj)
4337			if out.Values[i] == graphql.Null {
4338				invalid = true
4339			}
4340		case "deprecationReason":
4341			out.Values[i] = ec.___EnumValue_deprecationReason(ctx, field, obj)
4342		default:
4343			panic("unknown field " + strconv.Quote(field.Name))
4344		}
4345	}
4346
4347	if invalid {
4348		return graphql.Null
4349	}
4350	return out
4351}
4352
4353// nolint: vetshadow
4354func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) graphql.Marshaler {
4355	rctx := &graphql.ResolverContext{
4356		Object: "__EnumValue",
4357		Args:   nil,
4358		Field:  field,
4359	}
4360	ctx = graphql.WithResolverContext(ctx, rctx)
4361	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
4362		return obj.Name, nil
4363	})
4364	if resTmp == nil {
4365		if !ec.HasError(rctx) {
4366			ec.Errorf(ctx, "must not be null")
4367		}
4368		return graphql.Null
4369	}
4370	res := resTmp.(string)
4371	rctx.Result = res
4372	return graphql.MarshalString(res)
4373}
4374
4375// nolint: vetshadow
4376func (ec *executionContext) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) graphql.Marshaler {
4377	rctx := &graphql.ResolverContext{
4378		Object: "__EnumValue",
4379		Args:   nil,
4380		Field:  field,
4381	}
4382	ctx = graphql.WithResolverContext(ctx, rctx)
4383	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
4384		return obj.Description, nil
4385	})
4386	if resTmp == nil {
4387		return graphql.Null
4388	}
4389	res := resTmp.(string)
4390	rctx.Result = res
4391	return graphql.MarshalString(res)
4392}
4393
4394// nolint: vetshadow
4395func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) graphql.Marshaler {
4396	rctx := &graphql.ResolverContext{
4397		Object: "__EnumValue",
4398		Args:   nil,
4399		Field:  field,
4400	}
4401	ctx = graphql.WithResolverContext(ctx, rctx)
4402	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
4403		return obj.IsDeprecated, nil
4404	})
4405	if resTmp == nil {
4406		if !ec.HasError(rctx) {
4407			ec.Errorf(ctx, "must not be null")
4408		}
4409		return graphql.Null
4410	}
4411	res := resTmp.(bool)
4412	rctx.Result = res
4413	return graphql.MarshalBoolean(res)
4414}
4415
4416// nolint: vetshadow
4417func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) graphql.Marshaler {
4418	rctx := &graphql.ResolverContext{
4419		Object: "__EnumValue",
4420		Args:   nil,
4421		Field:  field,
4422	}
4423	ctx = graphql.WithResolverContext(ctx, rctx)
4424	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
4425		return obj.DeprecationReason, nil
4426	})
4427	if resTmp == nil {
4428		return graphql.Null
4429	}
4430	res := resTmp.(string)
4431	rctx.Result = res
4432	return graphql.MarshalString(res)
4433}
4434
4435var __FieldImplementors = []string{"__Field"}
4436
4437// nolint: gocyclo, errcheck, gas, goconst
4438func (ec *executionContext) ___Field(ctx context.Context, sel ast.SelectionSet, obj *introspection.Field) graphql.Marshaler {
4439	fields := graphql.CollectFields(ctx, sel, __FieldImplementors)
4440
4441	out := graphql.NewOrderedMap(len(fields))
4442	invalid := false
4443	for i, field := range fields {
4444		out.Keys[i] = field.Alias
4445
4446		switch field.Name {
4447		case "__typename":
4448			out.Values[i] = graphql.MarshalString("__Field")
4449		case "name":
4450			out.Values[i] = ec.___Field_name(ctx, field, obj)
4451			if out.Values[i] == graphql.Null {
4452				invalid = true
4453			}
4454		case "description":
4455			out.Values[i] = ec.___Field_description(ctx, field, obj)
4456		case "args":
4457			out.Values[i] = ec.___Field_args(ctx, field, obj)
4458			if out.Values[i] == graphql.Null {
4459				invalid = true
4460			}
4461		case "type":
4462			out.Values[i] = ec.___Field_type(ctx, field, obj)
4463			if out.Values[i] == graphql.Null {
4464				invalid = true
4465			}
4466		case "isDeprecated":
4467			out.Values[i] = ec.___Field_isDeprecated(ctx, field, obj)
4468			if out.Values[i] == graphql.Null {
4469				invalid = true
4470			}
4471		case "deprecationReason":
4472			out.Values[i] = ec.___Field_deprecationReason(ctx, field, obj)
4473		default:
4474			panic("unknown field " + strconv.Quote(field.Name))
4475		}
4476	}
4477
4478	if invalid {
4479		return graphql.Null
4480	}
4481	return out
4482}
4483
4484// nolint: vetshadow
4485func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) graphql.Marshaler {
4486	rctx := &graphql.ResolverContext{
4487		Object: "__Field",
4488		Args:   nil,
4489		Field:  field,
4490	}
4491	ctx = graphql.WithResolverContext(ctx, rctx)
4492	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
4493		return obj.Name, nil
4494	})
4495	if resTmp == nil {
4496		if !ec.HasError(rctx) {
4497			ec.Errorf(ctx, "must not be null")
4498		}
4499		return graphql.Null
4500	}
4501	res := resTmp.(string)
4502	rctx.Result = res
4503	return graphql.MarshalString(res)
4504}
4505
4506// nolint: vetshadow
4507func (ec *executionContext) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) graphql.Marshaler {
4508	rctx := &graphql.ResolverContext{
4509		Object: "__Field",
4510		Args:   nil,
4511		Field:  field,
4512	}
4513	ctx = graphql.WithResolverContext(ctx, rctx)
4514	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
4515		return obj.Description, nil
4516	})
4517	if resTmp == nil {
4518		return graphql.Null
4519	}
4520	res := resTmp.(string)
4521	rctx.Result = res
4522	return graphql.MarshalString(res)
4523}
4524
4525// nolint: vetshadow
4526func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) graphql.Marshaler {
4527	rctx := &graphql.ResolverContext{
4528		Object: "__Field",
4529		Args:   nil,
4530		Field:  field,
4531	}
4532	ctx = graphql.WithResolverContext(ctx, rctx)
4533	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
4534		return obj.Args, nil
4535	})
4536	if resTmp == nil {
4537		if !ec.HasError(rctx) {
4538			ec.Errorf(ctx, "must not be null")
4539		}
4540		return graphql.Null
4541	}
4542	res := resTmp.([]introspection.InputValue)
4543	rctx.Result = res
4544
4545	arr1 := make(graphql.Array, len(res))
4546	var wg sync.WaitGroup
4547
4548	isLen1 := len(res) == 1
4549	if !isLen1 {
4550		wg.Add(len(res))
4551	}
4552
4553	for idx1 := range res {
4554		idx1 := idx1
4555		rctx := &graphql.ResolverContext{
4556			Index:  &idx1,
4557			Result: &res[idx1],
4558		}
4559		ctx := graphql.WithResolverContext(ctx, rctx)
4560		f := func(idx1 int) {
4561			if !isLen1 {
4562				defer wg.Done()
4563			}
4564			arr1[idx1] = func() graphql.Marshaler {
4565
4566				return ec.___InputValue(ctx, field.Selections, &res[idx1])
4567			}()
4568		}
4569		if isLen1 {
4570			f(idx1)
4571		} else {
4572			go f(idx1)
4573		}
4574
4575	}
4576	wg.Wait()
4577	return arr1
4578}
4579
4580// nolint: vetshadow
4581func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) graphql.Marshaler {
4582	rctx := &graphql.ResolverContext{
4583		Object: "__Field",
4584		Args:   nil,
4585		Field:  field,
4586	}
4587	ctx = graphql.WithResolverContext(ctx, rctx)
4588	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
4589		return obj.Type, nil
4590	})
4591	if resTmp == nil {
4592		if !ec.HasError(rctx) {
4593			ec.Errorf(ctx, "must not be null")
4594		}
4595		return graphql.Null
4596	}
4597	res := resTmp.(*introspection.Type)
4598	rctx.Result = res
4599
4600	if res == nil {
4601		if !ec.HasError(rctx) {
4602			ec.Errorf(ctx, "must not be null")
4603		}
4604		return graphql.Null
4605	}
4606
4607	return ec.___Type(ctx, field.Selections, res)
4608}
4609
4610// nolint: vetshadow
4611func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) graphql.Marshaler {
4612	rctx := &graphql.ResolverContext{
4613		Object: "__Field",
4614		Args:   nil,
4615		Field:  field,
4616	}
4617	ctx = graphql.WithResolverContext(ctx, rctx)
4618	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
4619		return obj.IsDeprecated, nil
4620	})
4621	if resTmp == nil {
4622		if !ec.HasError(rctx) {
4623			ec.Errorf(ctx, "must not be null")
4624		}
4625		return graphql.Null
4626	}
4627	res := resTmp.(bool)
4628	rctx.Result = res
4629	return graphql.MarshalBoolean(res)
4630}
4631
4632// nolint: vetshadow
4633func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) graphql.Marshaler {
4634	rctx := &graphql.ResolverContext{
4635		Object: "__Field",
4636		Args:   nil,
4637		Field:  field,
4638	}
4639	ctx = graphql.WithResolverContext(ctx, rctx)
4640	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
4641		return obj.DeprecationReason, nil
4642	})
4643	if resTmp == nil {
4644		return graphql.Null
4645	}
4646	res := resTmp.(string)
4647	rctx.Result = res
4648	return graphql.MarshalString(res)
4649}
4650
4651var __InputValueImplementors = []string{"__InputValue"}
4652
4653// nolint: gocyclo, errcheck, gas, goconst
4654func (ec *executionContext) ___InputValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.InputValue) graphql.Marshaler {
4655	fields := graphql.CollectFields(ctx, sel, __InputValueImplementors)
4656
4657	out := graphql.NewOrderedMap(len(fields))
4658	invalid := false
4659	for i, field := range fields {
4660		out.Keys[i] = field.Alias
4661
4662		switch field.Name {
4663		case "__typename":
4664			out.Values[i] = graphql.MarshalString("__InputValue")
4665		case "name":
4666			out.Values[i] = ec.___InputValue_name(ctx, field, obj)
4667			if out.Values[i] == graphql.Null {
4668				invalid = true
4669			}
4670		case "description":
4671			out.Values[i] = ec.___InputValue_description(ctx, field, obj)
4672		case "type":
4673			out.Values[i] = ec.___InputValue_type(ctx, field, obj)
4674			if out.Values[i] == graphql.Null {
4675				invalid = true
4676			}
4677		case "defaultValue":
4678			out.Values[i] = ec.___InputValue_defaultValue(ctx, field, obj)
4679		default:
4680			panic("unknown field " + strconv.Quote(field.Name))
4681		}
4682	}
4683
4684	if invalid {
4685		return graphql.Null
4686	}
4687	return out
4688}
4689
4690// nolint: vetshadow
4691func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) graphql.Marshaler {
4692	rctx := &graphql.ResolverContext{
4693		Object: "__InputValue",
4694		Args:   nil,
4695		Field:  field,
4696	}
4697	ctx = graphql.WithResolverContext(ctx, rctx)
4698	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
4699		return obj.Name, nil
4700	})
4701	if resTmp == nil {
4702		if !ec.HasError(rctx) {
4703			ec.Errorf(ctx, "must not be null")
4704		}
4705		return graphql.Null
4706	}
4707	res := resTmp.(string)
4708	rctx.Result = res
4709	return graphql.MarshalString(res)
4710}
4711
4712// nolint: vetshadow
4713func (ec *executionContext) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) graphql.Marshaler {
4714	rctx := &graphql.ResolverContext{
4715		Object: "__InputValue",
4716		Args:   nil,
4717		Field:  field,
4718	}
4719	ctx = graphql.WithResolverContext(ctx, rctx)
4720	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
4721		return obj.Description, nil
4722	})
4723	if resTmp == nil {
4724		return graphql.Null
4725	}
4726	res := resTmp.(string)
4727	rctx.Result = res
4728	return graphql.MarshalString(res)
4729}
4730
4731// nolint: vetshadow
4732func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) graphql.Marshaler {
4733	rctx := &graphql.ResolverContext{
4734		Object: "__InputValue",
4735		Args:   nil,
4736		Field:  field,
4737	}
4738	ctx = graphql.WithResolverContext(ctx, rctx)
4739	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
4740		return obj.Type, nil
4741	})
4742	if resTmp == nil {
4743		if !ec.HasError(rctx) {
4744			ec.Errorf(ctx, "must not be null")
4745		}
4746		return graphql.Null
4747	}
4748	res := resTmp.(*introspection.Type)
4749	rctx.Result = res
4750
4751	if res == nil {
4752		if !ec.HasError(rctx) {
4753			ec.Errorf(ctx, "must not be null")
4754		}
4755		return graphql.Null
4756	}
4757
4758	return ec.___Type(ctx, field.Selections, res)
4759}
4760
4761// nolint: vetshadow
4762func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) graphql.Marshaler {
4763	rctx := &graphql.ResolverContext{
4764		Object: "__InputValue",
4765		Args:   nil,
4766		Field:  field,
4767	}
4768	ctx = graphql.WithResolverContext(ctx, rctx)
4769	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
4770		return obj.DefaultValue, nil
4771	})
4772	if resTmp == nil {
4773		return graphql.Null
4774	}
4775	res := resTmp.(*string)
4776	rctx.Result = res
4777
4778	if res == nil {
4779		return graphql.Null
4780	}
4781	return graphql.MarshalString(*res)
4782}
4783
4784var __SchemaImplementors = []string{"__Schema"}
4785
4786// nolint: gocyclo, errcheck, gas, goconst
4787func (ec *executionContext) ___Schema(ctx context.Context, sel ast.SelectionSet, obj *introspection.Schema) graphql.Marshaler {
4788	fields := graphql.CollectFields(ctx, sel, __SchemaImplementors)
4789
4790	out := graphql.NewOrderedMap(len(fields))
4791	invalid := false
4792	for i, field := range fields {
4793		out.Keys[i] = field.Alias
4794
4795		switch field.Name {
4796		case "__typename":
4797			out.Values[i] = graphql.MarshalString("__Schema")
4798		case "types":
4799			out.Values[i] = ec.___Schema_types(ctx, field, obj)
4800			if out.Values[i] == graphql.Null {
4801				invalid = true
4802			}
4803		case "queryType":
4804			out.Values[i] = ec.___Schema_queryType(ctx, field, obj)
4805			if out.Values[i] == graphql.Null {
4806				invalid = true
4807			}
4808		case "mutationType":
4809			out.Values[i] = ec.___Schema_mutationType(ctx, field, obj)
4810		case "subscriptionType":
4811			out.Values[i] = ec.___Schema_subscriptionType(ctx, field, obj)
4812		case "directives":
4813			out.Values[i] = ec.___Schema_directives(ctx, field, obj)
4814			if out.Values[i] == graphql.Null {
4815				invalid = true
4816			}
4817		default:
4818			panic("unknown field " + strconv.Quote(field.Name))
4819		}
4820	}
4821
4822	if invalid {
4823		return graphql.Null
4824	}
4825	return out
4826}
4827
4828// nolint: vetshadow
4829func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) graphql.Marshaler {
4830	rctx := &graphql.ResolverContext{
4831		Object: "__Schema",
4832		Args:   nil,
4833		Field:  field,
4834	}
4835	ctx = graphql.WithResolverContext(ctx, rctx)
4836	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
4837		return obj.Types(), 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.([]introspection.Type)
4846	rctx.Result = res
4847
4848	arr1 := make(graphql.Array, len(res))
4849	var wg sync.WaitGroup
4850
4851	isLen1 := len(res) == 1
4852	if !isLen1 {
4853		wg.Add(len(res))
4854	}
4855
4856	for idx1 := range res {
4857		idx1 := idx1
4858		rctx := &graphql.ResolverContext{
4859			Index:  &idx1,
4860			Result: &res[idx1],
4861		}
4862		ctx := graphql.WithResolverContext(ctx, rctx)
4863		f := func(idx1 int) {
4864			if !isLen1 {
4865				defer wg.Done()
4866			}
4867			arr1[idx1] = func() graphql.Marshaler {
4868
4869				return ec.___Type(ctx, field.Selections, &res[idx1])
4870			}()
4871		}
4872		if isLen1 {
4873			f(idx1)
4874		} else {
4875			go f(idx1)
4876		}
4877
4878	}
4879	wg.Wait()
4880	return arr1
4881}
4882
4883// nolint: vetshadow
4884func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) graphql.Marshaler {
4885	rctx := &graphql.ResolverContext{
4886		Object: "__Schema",
4887		Args:   nil,
4888		Field:  field,
4889	}
4890	ctx = graphql.WithResolverContext(ctx, rctx)
4891	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
4892		return obj.QueryType(), nil
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.(*introspection.Type)
4901	rctx.Result = res
4902
4903	if res == nil {
4904		if !ec.HasError(rctx) {
4905			ec.Errorf(ctx, "must not be null")
4906		}
4907		return graphql.Null
4908	}
4909
4910	return ec.___Type(ctx, field.Selections, res)
4911}
4912
4913// nolint: vetshadow
4914func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) graphql.Marshaler {
4915	rctx := &graphql.ResolverContext{
4916		Object: "__Schema",
4917		Args:   nil,
4918		Field:  field,
4919	}
4920	ctx = graphql.WithResolverContext(ctx, rctx)
4921	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
4922		return obj.MutationType(), nil
4923	})
4924	if resTmp == nil {
4925		return graphql.Null
4926	}
4927	res := resTmp.(*introspection.Type)
4928	rctx.Result = res
4929
4930	if res == nil {
4931		return graphql.Null
4932	}
4933
4934	return ec.___Type(ctx, field.Selections, res)
4935}
4936
4937// nolint: vetshadow
4938func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) graphql.Marshaler {
4939	rctx := &graphql.ResolverContext{
4940		Object: "__Schema",
4941		Args:   nil,
4942		Field:  field,
4943	}
4944	ctx = graphql.WithResolverContext(ctx, rctx)
4945	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
4946		return obj.SubscriptionType(), nil
4947	})
4948	if resTmp == nil {
4949		return graphql.Null
4950	}
4951	res := resTmp.(*introspection.Type)
4952	rctx.Result = res
4953
4954	if res == nil {
4955		return graphql.Null
4956	}
4957
4958	return ec.___Type(ctx, field.Selections, res)
4959}
4960
4961// nolint: vetshadow
4962func (ec *executionContext) ___Schema_directives(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) graphql.Marshaler {
4963	rctx := &graphql.ResolverContext{
4964		Object: "__Schema",
4965		Args:   nil,
4966		Field:  field,
4967	}
4968	ctx = graphql.WithResolverContext(ctx, rctx)
4969	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
4970		return obj.Directives(), nil
4971	})
4972	if resTmp == nil {
4973		if !ec.HasError(rctx) {
4974			ec.Errorf(ctx, "must not be null")
4975		}
4976		return graphql.Null
4977	}
4978	res := resTmp.([]introspection.Directive)
4979	rctx.Result = res
4980
4981	arr1 := make(graphql.Array, len(res))
4982	var wg sync.WaitGroup
4983
4984	isLen1 := len(res) == 1
4985	if !isLen1 {
4986		wg.Add(len(res))
4987	}
4988
4989	for idx1 := range res {
4990		idx1 := idx1
4991		rctx := &graphql.ResolverContext{
4992			Index:  &idx1,
4993			Result: &res[idx1],
4994		}
4995		ctx := graphql.WithResolverContext(ctx, rctx)
4996		f := func(idx1 int) {
4997			if !isLen1 {
4998				defer wg.Done()
4999			}
5000			arr1[idx1] = func() graphql.Marshaler {
5001
5002				return ec.___Directive(ctx, field.Selections, &res[idx1])
5003			}()
5004		}
5005		if isLen1 {
5006			f(idx1)
5007		} else {
5008			go f(idx1)
5009		}
5010
5011	}
5012	wg.Wait()
5013	return arr1
5014}
5015
5016var __TypeImplementors = []string{"__Type"}
5017
5018// nolint: gocyclo, errcheck, gas, goconst
5019func (ec *executionContext) ___Type(ctx context.Context, sel ast.SelectionSet, obj *introspection.Type) graphql.Marshaler {
5020	fields := graphql.CollectFields(ctx, sel, __TypeImplementors)
5021
5022	out := graphql.NewOrderedMap(len(fields))
5023	invalid := false
5024	for i, field := range fields {
5025		out.Keys[i] = field.Alias
5026
5027		switch field.Name {
5028		case "__typename":
5029			out.Values[i] = graphql.MarshalString("__Type")
5030		case "kind":
5031			out.Values[i] = ec.___Type_kind(ctx, field, obj)
5032			if out.Values[i] == graphql.Null {
5033				invalid = true
5034			}
5035		case "name":
5036			out.Values[i] = ec.___Type_name(ctx, field, obj)
5037		case "description":
5038			out.Values[i] = ec.___Type_description(ctx, field, obj)
5039		case "fields":
5040			out.Values[i] = ec.___Type_fields(ctx, field, obj)
5041		case "interfaces":
5042			out.Values[i] = ec.___Type_interfaces(ctx, field, obj)
5043		case "possibleTypes":
5044			out.Values[i] = ec.___Type_possibleTypes(ctx, field, obj)
5045		case "enumValues":
5046			out.Values[i] = ec.___Type_enumValues(ctx, field, obj)
5047		case "inputFields":
5048			out.Values[i] = ec.___Type_inputFields(ctx, field, obj)
5049		case "ofType":
5050			out.Values[i] = ec.___Type_ofType(ctx, field, obj)
5051		default:
5052			panic("unknown field " + strconv.Quote(field.Name))
5053		}
5054	}
5055
5056	if invalid {
5057		return graphql.Null
5058	}
5059	return out
5060}
5061
5062// nolint: vetshadow
5063func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler {
5064	rctx := &graphql.ResolverContext{
5065		Object: "__Type",
5066		Args:   nil,
5067		Field:  field,
5068	}
5069	ctx = graphql.WithResolverContext(ctx, rctx)
5070	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
5071		return obj.Kind(), nil
5072	})
5073	if resTmp == nil {
5074		if !ec.HasError(rctx) {
5075			ec.Errorf(ctx, "must not be null")
5076		}
5077		return graphql.Null
5078	}
5079	res := resTmp.(string)
5080	rctx.Result = res
5081	return graphql.MarshalString(res)
5082}
5083
5084// nolint: vetshadow
5085func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler {
5086	rctx := &graphql.ResolverContext{
5087		Object: "__Type",
5088		Args:   nil,
5089		Field:  field,
5090	}
5091	ctx = graphql.WithResolverContext(ctx, rctx)
5092	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
5093		return obj.Name(), nil
5094	})
5095	if resTmp == nil {
5096		return graphql.Null
5097	}
5098	res := resTmp.(*string)
5099	rctx.Result = res
5100
5101	if res == nil {
5102		return graphql.Null
5103	}
5104	return graphql.MarshalString(*res)
5105}
5106
5107// nolint: vetshadow
5108func (ec *executionContext) ___Type_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler {
5109	rctx := &graphql.ResolverContext{
5110		Object: "__Type",
5111		Args:   nil,
5112		Field:  field,
5113	}
5114	ctx = graphql.WithResolverContext(ctx, rctx)
5115	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
5116		return obj.Description(), nil
5117	})
5118	if resTmp == nil {
5119		return graphql.Null
5120	}
5121	res := resTmp.(string)
5122	rctx.Result = res
5123	return graphql.MarshalString(res)
5124}
5125
5126// nolint: vetshadow
5127func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler {
5128	rawArgs := field.ArgumentMap(ec.Variables)
5129	args, err := field___Type_fields_args(rawArgs)
5130	if err != nil {
5131		ec.Error(ctx, err)
5132		return graphql.Null
5133	}
5134	rctx := &graphql.ResolverContext{
5135		Object: "__Type",
5136		Args:   args,
5137		Field:  field,
5138	}
5139	ctx = graphql.WithResolverContext(ctx, rctx)
5140	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
5141		return obj.Fields(args["includeDeprecated"].(bool)), nil
5142	})
5143	if resTmp == nil {
5144		return graphql.Null
5145	}
5146	res := resTmp.([]introspection.Field)
5147	rctx.Result = res
5148
5149	arr1 := make(graphql.Array, len(res))
5150	var wg sync.WaitGroup
5151
5152	isLen1 := len(res) == 1
5153	if !isLen1 {
5154		wg.Add(len(res))
5155	}
5156
5157	for idx1 := range res {
5158		idx1 := idx1
5159		rctx := &graphql.ResolverContext{
5160			Index:  &idx1,
5161			Result: &res[idx1],
5162		}
5163		ctx := graphql.WithResolverContext(ctx, rctx)
5164		f := func(idx1 int) {
5165			if !isLen1 {
5166				defer wg.Done()
5167			}
5168			arr1[idx1] = func() graphql.Marshaler {
5169
5170				return ec.___Field(ctx, field.Selections, &res[idx1])
5171			}()
5172		}
5173		if isLen1 {
5174			f(idx1)
5175		} else {
5176			go f(idx1)
5177		}
5178
5179	}
5180	wg.Wait()
5181	return arr1
5182}
5183
5184// nolint: vetshadow
5185func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler {
5186	rctx := &graphql.ResolverContext{
5187		Object: "__Type",
5188		Args:   nil,
5189		Field:  field,
5190	}
5191	ctx = graphql.WithResolverContext(ctx, rctx)
5192	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
5193		return obj.Interfaces(), nil
5194	})
5195	if resTmp == nil {
5196		return graphql.Null
5197	}
5198	res := resTmp.([]introspection.Type)
5199	rctx.Result = res
5200
5201	arr1 := make(graphql.Array, len(res))
5202	var wg sync.WaitGroup
5203
5204	isLen1 := len(res) == 1
5205	if !isLen1 {
5206		wg.Add(len(res))
5207	}
5208
5209	for idx1 := range res {
5210		idx1 := idx1
5211		rctx := &graphql.ResolverContext{
5212			Index:  &idx1,
5213			Result: &res[idx1],
5214		}
5215		ctx := graphql.WithResolverContext(ctx, rctx)
5216		f := func(idx1 int) {
5217			if !isLen1 {
5218				defer wg.Done()
5219			}
5220			arr1[idx1] = func() graphql.Marshaler {
5221
5222				return ec.___Type(ctx, field.Selections, &res[idx1])
5223			}()
5224		}
5225		if isLen1 {
5226			f(idx1)
5227		} else {
5228			go f(idx1)
5229		}
5230
5231	}
5232	wg.Wait()
5233	return arr1
5234}
5235
5236// nolint: vetshadow
5237func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler {
5238	rctx := &graphql.ResolverContext{
5239		Object: "__Type",
5240		Args:   nil,
5241		Field:  field,
5242	}
5243	ctx = graphql.WithResolverContext(ctx, rctx)
5244	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
5245		return obj.PossibleTypes(), nil
5246	})
5247	if resTmp == nil {
5248		return graphql.Null
5249	}
5250	res := resTmp.([]introspection.Type)
5251	rctx.Result = res
5252
5253	arr1 := make(graphql.Array, len(res))
5254	var wg sync.WaitGroup
5255
5256	isLen1 := len(res) == 1
5257	if !isLen1 {
5258		wg.Add(len(res))
5259	}
5260
5261	for idx1 := range res {
5262		idx1 := idx1
5263		rctx := &graphql.ResolverContext{
5264			Index:  &idx1,
5265			Result: &res[idx1],
5266		}
5267		ctx := graphql.WithResolverContext(ctx, rctx)
5268		f := func(idx1 int) {
5269			if !isLen1 {
5270				defer wg.Done()
5271			}
5272			arr1[idx1] = func() graphql.Marshaler {
5273
5274				return ec.___Type(ctx, field.Selections, &res[idx1])
5275			}()
5276		}
5277		if isLen1 {
5278			f(idx1)
5279		} else {
5280			go f(idx1)
5281		}
5282
5283	}
5284	wg.Wait()
5285	return arr1
5286}
5287
5288// nolint: vetshadow
5289func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler {
5290	rawArgs := field.ArgumentMap(ec.Variables)
5291	args, err := field___Type_enumValues_args(rawArgs)
5292	if err != nil {
5293		ec.Error(ctx, err)
5294		return graphql.Null
5295	}
5296	rctx := &graphql.ResolverContext{
5297		Object: "__Type",
5298		Args:   args,
5299		Field:  field,
5300	}
5301	ctx = graphql.WithResolverContext(ctx, rctx)
5302	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
5303		return obj.EnumValues(args["includeDeprecated"].(bool)), nil
5304	})
5305	if resTmp == nil {
5306		return graphql.Null
5307	}
5308	res := resTmp.([]introspection.EnumValue)
5309	rctx.Result = res
5310
5311	arr1 := make(graphql.Array, len(res))
5312	var wg sync.WaitGroup
5313
5314	isLen1 := len(res) == 1
5315	if !isLen1 {
5316		wg.Add(len(res))
5317	}
5318
5319	for idx1 := range res {
5320		idx1 := idx1
5321		rctx := &graphql.ResolverContext{
5322			Index:  &idx1,
5323			Result: &res[idx1],
5324		}
5325		ctx := graphql.WithResolverContext(ctx, rctx)
5326		f := func(idx1 int) {
5327			if !isLen1 {
5328				defer wg.Done()
5329			}
5330			arr1[idx1] = func() graphql.Marshaler {
5331
5332				return ec.___EnumValue(ctx, field.Selections, &res[idx1])
5333			}()
5334		}
5335		if isLen1 {
5336			f(idx1)
5337		} else {
5338			go f(idx1)
5339		}
5340
5341	}
5342	wg.Wait()
5343	return arr1
5344}
5345
5346// nolint: vetshadow
5347func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler {
5348	rctx := &graphql.ResolverContext{
5349		Object: "__Type",
5350		Args:   nil,
5351		Field:  field,
5352	}
5353	ctx = graphql.WithResolverContext(ctx, rctx)
5354	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
5355		return obj.InputFields(), nil
5356	})
5357	if resTmp == nil {
5358		return graphql.Null
5359	}
5360	res := resTmp.([]introspection.InputValue)
5361	rctx.Result = res
5362
5363	arr1 := make(graphql.Array, len(res))
5364	var wg sync.WaitGroup
5365
5366	isLen1 := len(res) == 1
5367	if !isLen1 {
5368		wg.Add(len(res))
5369	}
5370
5371	for idx1 := range res {
5372		idx1 := idx1
5373		rctx := &graphql.ResolverContext{
5374			Index:  &idx1,
5375			Result: &res[idx1],
5376		}
5377		ctx := graphql.WithResolverContext(ctx, rctx)
5378		f := func(idx1 int) {
5379			if !isLen1 {
5380				defer wg.Done()
5381			}
5382			arr1[idx1] = func() graphql.Marshaler {
5383
5384				return ec.___InputValue(ctx, field.Selections, &res[idx1])
5385			}()
5386		}
5387		if isLen1 {
5388			f(idx1)
5389		} else {
5390			go f(idx1)
5391		}
5392
5393	}
5394	wg.Wait()
5395	return arr1
5396}
5397
5398// nolint: vetshadow
5399func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler {
5400	rctx := &graphql.ResolverContext{
5401		Object: "__Type",
5402		Args:   nil,
5403		Field:  field,
5404	}
5405	ctx = graphql.WithResolverContext(ctx, rctx)
5406	resTmp := ec.FieldMiddleware(ctx, obj, func(ctx context.Context) (interface{}, error) {
5407		return obj.OfType(), nil
5408	})
5409	if resTmp == nil {
5410		return graphql.Null
5411	}
5412	res := resTmp.(*introspection.Type)
5413	rctx.Result = res
5414
5415	if res == nil {
5416		return graphql.Null
5417	}
5418
5419	return ec.___Type(ctx, field.Selections, res)
5420}
5421
5422func (ec *executionContext) _Authored(ctx context.Context, sel ast.SelectionSet, obj *models.Authored) graphql.Marshaler {
5423	switch obj := (*obj).(type) {
5424	case nil:
5425		return graphql.Null
5426	case bug.Comment:
5427		return ec._Comment(ctx, sel, &obj)
5428	case *bug.Comment:
5429		return ec._Comment(ctx, sel, obj)
5430	case operations.CreateOperation:
5431		return ec._CreateOperation(ctx, sel, &obj)
5432	case *operations.CreateOperation:
5433		return ec._CreateOperation(ctx, sel, obj)
5434	case operations.SetTitleOperation:
5435		return ec._SetTitleOperation(ctx, sel, &obj)
5436	case *operations.SetTitleOperation:
5437		return ec._SetTitleOperation(ctx, sel, obj)
5438	case operations.AddCommentOperation:
5439		return ec._AddCommentOperation(ctx, sel, &obj)
5440	case *operations.AddCommentOperation:
5441		return ec._AddCommentOperation(ctx, sel, obj)
5442	case operations.SetStatusOperation:
5443		return ec._SetStatusOperation(ctx, sel, &obj)
5444	case *operations.SetStatusOperation:
5445		return ec._SetStatusOperation(ctx, sel, obj)
5446	case operations.LabelChangeOperation:
5447		return ec._LabelChangeOperation(ctx, sel, &obj)
5448	case *operations.LabelChangeOperation:
5449		return ec._LabelChangeOperation(ctx, sel, obj)
5450	default:
5451		panic(fmt.Errorf("unexpected type %T", obj))
5452	}
5453}
5454
5455func (ec *executionContext) _Operation(ctx context.Context, sel ast.SelectionSet, obj *bug.Operation) graphql.Marshaler {
5456	switch obj := (*obj).(type) {
5457	case nil:
5458		return graphql.Null
5459	case operations.CreateOperation:
5460		return ec._CreateOperation(ctx, sel, &obj)
5461	case *operations.CreateOperation:
5462		return ec._CreateOperation(ctx, sel, obj)
5463	case operations.SetTitleOperation:
5464		return ec._SetTitleOperation(ctx, sel, &obj)
5465	case *operations.SetTitleOperation:
5466		return ec._SetTitleOperation(ctx, sel, obj)
5467	case operations.AddCommentOperation:
5468		return ec._AddCommentOperation(ctx, sel, &obj)
5469	case *operations.AddCommentOperation:
5470		return ec._AddCommentOperation(ctx, sel, obj)
5471	case operations.SetStatusOperation:
5472		return ec._SetStatusOperation(ctx, sel, &obj)
5473	case *operations.SetStatusOperation:
5474		return ec._SetStatusOperation(ctx, sel, obj)
5475	case operations.LabelChangeOperation:
5476		return ec._LabelChangeOperation(ctx, sel, &obj)
5477	case *operations.LabelChangeOperation:
5478		return ec._LabelChangeOperation(ctx, sel, obj)
5479	default:
5480		panic(fmt.Errorf("unexpected type %T", obj))
5481	}
5482}
5483
5484func (ec *executionContext) FieldMiddleware(ctx context.Context, obj interface{}, next graphql.Resolver) (ret interface{}) {
5485	defer func() {
5486		if r := recover(); r != nil {
5487			ec.Error(ctx, ec.Recover(ctx, r))
5488			ret = nil
5489		}
5490	}()
5491	res, err := ec.ResolverMiddleware(ctx, next)
5492	if err != nil {
5493		ec.Error(ctx, err)
5494		return nil
5495	}
5496	return res
5497}
5498
5499func (ec *executionContext) introspectSchema() *introspection.Schema {
5500	return introspection.WrapSchema(parsedSchema)
5501}
5502
5503func (ec *executionContext) introspectType(name string) *introspection.Type {
5504	return introspection.WrapTypeFromDef(parsedSchema, parsedSchema.Types[name])
5505}
5506
5507var parsedSchema = gqlparser.MustLoadSchema(
5508	&ast.Source{Name: "schema.graphql", Input: `scalar Time
5509scalar Label
5510scalar Hash
5511
5512"""Information about pagination in a connection."""
5513type PageInfo {
5514  """When paginating forwards, are there more items?"""
5515  hasNextPage: Boolean!
5516  """When paginating backwards, are there more items?"""
5517  hasPreviousPage: Boolean!
5518  """When paginating backwards, the cursor to continue."""
5519  startCursor: String!
5520  """When paginating forwards, the cursor to continue."""
5521  endCursor: String!
5522}
5523
5524"""Represents an person in a git object."""
5525type Person {
5526  """The email of the person."""
5527  email: String
5528
5529  """The name of the person."""
5530  name: String
5531}
5532
5533type CommentConnection {
5534  edges: [CommentEdge!]!
5535  nodes: [Comment!]!
5536  pageInfo: PageInfo!
5537  totalCount: Int!
5538}
5539
5540type CommentEdge {
5541  cursor: String!
5542  node: Comment!
5543}
5544
5545"""Represents a comment on a bug."""
5546type Comment implements Authored {
5547  """The author of this comment."""
5548  author: Person!
5549
5550  """The message of this comment."""
5551  message: String!
5552
5553  """All media's hash referenced in this comment"""
5554  files: [Hash!]!
5555}
5556
5557enum Status {
5558  OPEN
5559  CLOSED
5560}
5561
5562"""An object that has an author."""
5563interface Authored {
5564  """The author of this object."""
5565  author: Person!
5566}
5567
5568type OperationConnection {
5569  edges: [OperationEdge!]!
5570  nodes: [Operation!]!
5571  pageInfo: PageInfo!
5572  totalCount: Int!
5573}
5574
5575type OperationEdge {
5576  cursor: String!
5577  node: Operation!
5578}
5579
5580"""An operation applied to a bug."""
5581interface Operation {
5582  """The operations author."""
5583  author: Person!
5584  """The datetime when this operation was issued."""
5585  date: Time!
5586}
5587
5588type CreateOperation implements Operation & Authored {
5589  author: Person!
5590  date: Time!
5591
5592  title: String!
5593  message: String!
5594  files: [Hash!]!
5595}
5596
5597type SetTitleOperation implements Operation & Authored {
5598  author: Person!
5599  date: Time!
5600
5601  title: String!
5602  was: String!
5603}
5604
5605type AddCommentOperation implements Operation & Authored {
5606  author: Person!
5607  date: Time!
5608
5609  message: String!
5610  files: [Hash!]!
5611}
5612
5613type SetStatusOperation implements Operation & Authored {
5614  author: Person!
5615  date: Time!
5616
5617  status: Status!
5618}
5619
5620type LabelChangeOperation implements Operation & Authored {
5621  author: Person!
5622  date: Time!
5623
5624  added: [Label!]!
5625  removed: [Label!]!
5626}
5627
5628"""The connection type for Bug."""
5629type BugConnection {
5630  """A list of edges."""
5631  edges: [BugEdge!]!
5632  nodes: [Bug!]!
5633  """Information to aid in pagination."""
5634  pageInfo: PageInfo!
5635  """Identifies the total count of items in the connection."""
5636  totalCount: Int!
5637}
5638
5639"""An edge in a connection."""
5640type BugEdge {
5641  """A cursor for use in pagination."""
5642  cursor: String!
5643  """The item at the end of the edge."""
5644  node: Bug!
5645}
5646
5647type Bug {
5648  id: String!
5649  humanId: String!
5650  status: Status!
5651  title: String!
5652  labels: [Label!]!
5653  author: Person!
5654  createdAt: Time!
5655  lastEdit: Time!
5656
5657  comments(
5658    """Returns the elements in the list that come after the specified cursor."""
5659    after: String
5660    """Returns the elements in the list that come before the specified cursor."""
5661    before: String
5662    """Returns the first _n_ elements from the list."""
5663    first: Int
5664    """Returns the last _n_ elements from the list."""
5665    last: Int
5666  ): CommentConnection!
5667
5668  operations(
5669    """Returns the elements in the list that come after the specified cursor."""
5670    after: String
5671    """Returns the elements in the list that come before the specified cursor."""
5672    before: String
5673    """Returns the first _n_ elements from the list."""
5674    first: Int
5675    """Returns the last _n_ elements from the list."""
5676    last: Int
5677  ): OperationConnection!
5678}
5679
5680type Repository {
5681  allBugs(
5682    """Returns the elements in the list that come after the specified cursor."""
5683    after: String
5684    """Returns the elements in the list that come before the specified cursor."""
5685    before: String
5686    """Returns the first _n_ elements from the list."""
5687    first: Int
5688    """Returns the last _n_ elements from the list."""
5689    last: Int
5690    """A query to select and order bugs"""
5691    query: String
5692  ): BugConnection!
5693  bug(prefix: String!): Bug
5694}
5695
5696type Query {
5697  defaultRepository: Repository
5698  repository(id: String!): Repository
5699}
5700
5701type Mutation {
5702  newBug(repoRef: String, title: String!, message: String!, files: [Hash!]): Bug!
5703
5704  addComment(repoRef: String, prefix: String!, message: String!, files: [Hash!]): Bug!
5705  changeLabels(repoRef: String, prefix: String!, added: [String!], removed: [String!]): Bug!
5706  open(repoRef: String, prefix: String!): Bug!
5707  close(repoRef: String, prefix: String!): Bug!
5708  setTitle(repoRef: String, prefix: String!, title: String!): Bug!
5709
5710  commit(repoRef: String, prefix: String!): Bug!
5711}
5712`},
5713)