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