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	"image/color"
   11	"strconv"
   12	"sync"
   13	"sync/atomic"
   14	"time"
   15
   16	"github.com/99designs/gqlgen/graphql"
   17	"github.com/99designs/gqlgen/graphql/introspection"
   18	"github.com/MichaelMure/git-bug/bug"
   19	"github.com/MichaelMure/git-bug/graphql/models"
   20	"github.com/MichaelMure/git-bug/identity"
   21	"github.com/MichaelMure/git-bug/util/git"
   22	"github.com/vektah/gqlparser"
   23	"github.com/vektah/gqlparser/ast"
   24)
   25
   26// region    ************************** generated!.gotpl **************************
   27
   28// NewExecutableSchema creates an ExecutableSchema from the ResolverRoot interface.
   29func NewExecutableSchema(cfg Config) graphql.ExecutableSchema {
   30	return &executableSchema{
   31		resolvers:  cfg.Resolvers,
   32		directives: cfg.Directives,
   33		complexity: cfg.Complexity,
   34	}
   35}
   36
   37type Config struct {
   38	Resolvers  ResolverRoot
   39	Directives DirectiveRoot
   40	Complexity ComplexityRoot
   41}
   42
   43type ResolverRoot interface {
   44	AddCommentOperation() AddCommentOperationResolver
   45	AddCommentTimelineItem() AddCommentTimelineItemResolver
   46	Bug() BugResolver
   47	Color() ColorResolver
   48	CommentHistoryStep() CommentHistoryStepResolver
   49	CreateOperation() CreateOperationResolver
   50	CreateTimelineItem() CreateTimelineItemResolver
   51	EditCommentOperation() EditCommentOperationResolver
   52	Identity() IdentityResolver
   53	Label() LabelResolver
   54	LabelChangeOperation() LabelChangeOperationResolver
   55	LabelChangeResult() LabelChangeResultResolver
   56	LabelChangeTimelineItem() LabelChangeTimelineItemResolver
   57	Mutation() MutationResolver
   58	Query() QueryResolver
   59	Repository() RepositoryResolver
   60	SetStatusOperation() SetStatusOperationResolver
   61	SetStatusTimelineItem() SetStatusTimelineItemResolver
   62	SetTitleOperation() SetTitleOperationResolver
   63	SetTitleTimelineItem() SetTitleTimelineItemResolver
   64}
   65
   66type DirectiveRoot struct {
   67}
   68
   69type ComplexityRoot struct {
   70	AddCommentOperation struct {
   71		Author  func(childComplexity int) int
   72		Date    func(childComplexity int) int
   73		Files   func(childComplexity int) int
   74		Hash    func(childComplexity int) int
   75		Message func(childComplexity int) int
   76	}
   77
   78	AddCommentPayload struct {
   79		Bug              func(childComplexity int) int
   80		ClientMutationID func(childComplexity int) int
   81		Operation        func(childComplexity int) int
   82	}
   83
   84	AddCommentTimelineItem struct {
   85		Author         func(childComplexity int) int
   86		CreatedAt      func(childComplexity int) int
   87		Edited         func(childComplexity int) int
   88		Files          func(childComplexity int) int
   89		Hash           func(childComplexity int) int
   90		History        func(childComplexity int) int
   91		LastEdit       func(childComplexity int) int
   92		Message        func(childComplexity int) int
   93		MessageIsEmpty func(childComplexity int) int
   94	}
   95
   96	Bug struct {
   97		Actors       func(childComplexity int, after *string, before *string, first *int, last *int) int
   98		Author       func(childComplexity int) int
   99		Comments     func(childComplexity int, after *string, before *string, first *int, last *int) int
  100		CreatedAt    func(childComplexity int) int
  101		HumanId      func(childComplexity int) int
  102		Id           func(childComplexity int) int
  103		Labels       func(childComplexity int) int
  104		LastEdit     func(childComplexity int) int
  105		Operations   func(childComplexity int, after *string, before *string, first *int, last *int) int
  106		Participants func(childComplexity int, after *string, before *string, first *int, last *int) int
  107		Status       func(childComplexity int) int
  108		Timeline     func(childComplexity int, after *string, before *string, first *int, last *int) int
  109		Title        func(childComplexity int) int
  110	}
  111
  112	BugConnection struct {
  113		Edges      func(childComplexity int) int
  114		Nodes      func(childComplexity int) int
  115		PageInfo   func(childComplexity int) int
  116		TotalCount func(childComplexity int) int
  117	}
  118
  119	BugEdge struct {
  120		Cursor func(childComplexity int) int
  121		Node   func(childComplexity int) int
  122	}
  123
  124	ChangeLabelPayload struct {
  125		Bug              func(childComplexity int) int
  126		ClientMutationID func(childComplexity int) int
  127		Operation        func(childComplexity int) int
  128		Results          func(childComplexity int) int
  129	}
  130
  131	CloseBugPayload struct {
  132		Bug              func(childComplexity int) int
  133		ClientMutationID func(childComplexity int) int
  134		Operation        func(childComplexity int) int
  135	}
  136
  137	Color struct {
  138		B func(childComplexity int) int
  139		G func(childComplexity int) int
  140		R func(childComplexity int) int
  141	}
  142
  143	Comment struct {
  144		Author  func(childComplexity int) int
  145		Files   func(childComplexity int) int
  146		Message func(childComplexity int) int
  147	}
  148
  149	CommentConnection struct {
  150		Edges      func(childComplexity int) int
  151		Nodes      func(childComplexity int) int
  152		PageInfo   func(childComplexity int) int
  153		TotalCount func(childComplexity int) int
  154	}
  155
  156	CommentEdge struct {
  157		Cursor func(childComplexity int) int
  158		Node   func(childComplexity int) int
  159	}
  160
  161	CommentHistoryStep struct {
  162		Date    func(childComplexity int) int
  163		Message func(childComplexity int) int
  164	}
  165
  166	CommitAsNeededPayload struct {
  167		Bug              func(childComplexity int) int
  168		ClientMutationID func(childComplexity int) int
  169	}
  170
  171	CommitPayload struct {
  172		Bug              func(childComplexity int) int
  173		ClientMutationID func(childComplexity int) int
  174	}
  175
  176	CreateOperation struct {
  177		Author  func(childComplexity int) int
  178		Date    func(childComplexity int) int
  179		Files   func(childComplexity int) int
  180		Hash    func(childComplexity int) int
  181		Message func(childComplexity int) int
  182		Title   func(childComplexity int) int
  183	}
  184
  185	CreateTimelineItem struct {
  186		Author         func(childComplexity int) int
  187		CreatedAt      func(childComplexity int) int
  188		Edited         func(childComplexity int) int
  189		Files          func(childComplexity int) int
  190		Hash           func(childComplexity int) int
  191		History        func(childComplexity int) int
  192		LastEdit       func(childComplexity int) int
  193		Message        func(childComplexity int) int
  194		MessageIsEmpty func(childComplexity int) int
  195	}
  196
  197	EditCommentOperation struct {
  198		Author  func(childComplexity int) int
  199		Date    func(childComplexity int) int
  200		Files   func(childComplexity int) int
  201		Hash    func(childComplexity int) int
  202		Message func(childComplexity int) int
  203		Target  func(childComplexity int) int
  204	}
  205
  206	Identity struct {
  207		AvatarURL   func(childComplexity int) int
  208		DisplayName func(childComplexity int) int
  209		Email       func(childComplexity int) int
  210		HumanID     func(childComplexity int) int
  211		ID          func(childComplexity int) int
  212		IsProtected func(childComplexity int) int
  213		Login       func(childComplexity int) int
  214		Name        func(childComplexity int) int
  215	}
  216
  217	IdentityConnection struct {
  218		Edges      func(childComplexity int) int
  219		Nodes      func(childComplexity int) int
  220		PageInfo   func(childComplexity int) int
  221		TotalCount func(childComplexity int) int
  222	}
  223
  224	IdentityEdge struct {
  225		Cursor func(childComplexity int) int
  226		Node   func(childComplexity int) int
  227	}
  228
  229	Label struct {
  230		Color func(childComplexity int) int
  231		Name  func(childComplexity int) int
  232	}
  233
  234	LabelChangeOperation struct {
  235		Added   func(childComplexity int) int
  236		Author  func(childComplexity int) int
  237		Date    func(childComplexity int) int
  238		Hash    func(childComplexity int) int
  239		Removed func(childComplexity int) int
  240	}
  241
  242	LabelChangeResult struct {
  243		Label  func(childComplexity int) int
  244		Status func(childComplexity int) int
  245	}
  246
  247	LabelChangeTimelineItem struct {
  248		Added   func(childComplexity int) int
  249		Author  func(childComplexity int) int
  250		Date    func(childComplexity int) int
  251		Hash    func(childComplexity int) int
  252		Removed func(childComplexity int) int
  253	}
  254
  255	Mutation struct {
  256		AddComment     func(childComplexity int, input models.AddCommentInput) int
  257		ChangeLabels   func(childComplexity int, input *models.ChangeLabelInput) int
  258		CloseBug       func(childComplexity int, input models.CloseBugInput) int
  259		Commit         func(childComplexity int, input models.CommitInput) int
  260		CommitAsNeeded func(childComplexity int, input models.CommitAsNeededInput) int
  261		NewBug         func(childComplexity int, input models.NewBugInput) int
  262		OpenBug        func(childComplexity int, input models.OpenBugInput) int
  263		SetTitle       func(childComplexity int, input models.SetTitleInput) int
  264	}
  265
  266	NewBugPayload struct {
  267		Bug              func(childComplexity int) int
  268		ClientMutationID func(childComplexity int) int
  269		Operation        func(childComplexity int) int
  270	}
  271
  272	OpenBugPayload struct {
  273		Bug              func(childComplexity int) int
  274		ClientMutationID func(childComplexity int) int
  275		Operation        func(childComplexity int) int
  276	}
  277
  278	OperationConnection struct {
  279		Edges      func(childComplexity int) int
  280		Nodes      func(childComplexity int) int
  281		PageInfo   func(childComplexity int) int
  282		TotalCount func(childComplexity int) int
  283	}
  284
  285	OperationEdge struct {
  286		Cursor func(childComplexity int) int
  287		Node   func(childComplexity int) int
  288	}
  289
  290	PageInfo struct {
  291		EndCursor       func(childComplexity int) int
  292		HasNextPage     func(childComplexity int) int
  293		HasPreviousPage func(childComplexity int) int
  294		StartCursor     func(childComplexity int) int
  295	}
  296
  297	Query struct {
  298		DefaultRepository func(childComplexity int) int
  299		Repository        func(childComplexity int, ref string) int
  300	}
  301
  302	Repository struct {
  303		AllBugs       func(childComplexity int, after *string, before *string, first *int, last *int, query *string) int
  304		AllIdentities func(childComplexity int, after *string, before *string, first *int, last *int) int
  305		Bug           func(childComplexity int, prefix string) int
  306		Identity      func(childComplexity int, prefix string) int
  307		UserIdentity  func(childComplexity int) int
  308		ValidLabels   func(childComplexity int) int
  309	}
  310
  311	SetStatusOperation struct {
  312		Author func(childComplexity int) int
  313		Date   func(childComplexity int) int
  314		Hash   func(childComplexity int) int
  315		Status func(childComplexity int) int
  316	}
  317
  318	SetStatusTimelineItem struct {
  319		Author func(childComplexity int) int
  320		Date   func(childComplexity int) int
  321		Hash   func(childComplexity int) int
  322		Status func(childComplexity int) int
  323	}
  324
  325	SetTitleOperation struct {
  326		Author func(childComplexity int) int
  327		Date   func(childComplexity int) int
  328		Hash   func(childComplexity int) int
  329		Title  func(childComplexity int) int
  330		Was    func(childComplexity int) int
  331	}
  332
  333	SetTitlePayload struct {
  334		Bug              func(childComplexity int) int
  335		ClientMutationID func(childComplexity int) int
  336		Operation        func(childComplexity int) int
  337	}
  338
  339	SetTitleTimelineItem struct {
  340		Author func(childComplexity int) int
  341		Date   func(childComplexity int) int
  342		Hash   func(childComplexity int) int
  343		Title  func(childComplexity int) int
  344		Was    func(childComplexity int) int
  345	}
  346
  347	TimelineItemConnection struct {
  348		Edges      func(childComplexity int) int
  349		Nodes      func(childComplexity int) int
  350		PageInfo   func(childComplexity int) int
  351		TotalCount func(childComplexity int) int
  352	}
  353
  354	TimelineItemEdge struct {
  355		Cursor func(childComplexity int) int
  356		Node   func(childComplexity int) int
  357	}
  358}
  359
  360type AddCommentOperationResolver interface {
  361	Date(ctx context.Context, obj *bug.AddCommentOperation) (*time.Time, error)
  362}
  363type AddCommentTimelineItemResolver interface {
  364	CreatedAt(ctx context.Context, obj *bug.AddCommentTimelineItem) (*time.Time, error)
  365	LastEdit(ctx context.Context, obj *bug.AddCommentTimelineItem) (*time.Time, error)
  366}
  367type BugResolver interface {
  368	Status(ctx context.Context, obj *bug.Snapshot) (models.Status, error)
  369
  370	LastEdit(ctx context.Context, obj *bug.Snapshot) (*time.Time, error)
  371	Actors(ctx context.Context, obj *bug.Snapshot, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
  372	Participants(ctx context.Context, obj *bug.Snapshot, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
  373	Comments(ctx context.Context, obj *bug.Snapshot, after *string, before *string, first *int, last *int) (*models.CommentConnection, error)
  374	Timeline(ctx context.Context, obj *bug.Snapshot, after *string, before *string, first *int, last *int) (*models.TimelineItemConnection, error)
  375	Operations(ctx context.Context, obj *bug.Snapshot, after *string, before *string, first *int, last *int) (*models.OperationConnection, error)
  376}
  377type ColorResolver interface {
  378	R(ctx context.Context, obj *color.RGBA) (int, error)
  379	G(ctx context.Context, obj *color.RGBA) (int, error)
  380	B(ctx context.Context, obj *color.RGBA) (int, error)
  381}
  382type CommentHistoryStepResolver interface {
  383	Date(ctx context.Context, obj *bug.CommentHistoryStep) (*time.Time, error)
  384}
  385type CreateOperationResolver interface {
  386	Date(ctx context.Context, obj *bug.CreateOperation) (*time.Time, error)
  387}
  388type CreateTimelineItemResolver interface {
  389	CreatedAt(ctx context.Context, obj *bug.CreateTimelineItem) (*time.Time, error)
  390	LastEdit(ctx context.Context, obj *bug.CreateTimelineItem) (*time.Time, error)
  391}
  392type EditCommentOperationResolver interface {
  393	Date(ctx context.Context, obj *bug.EditCommentOperation) (*time.Time, error)
  394}
  395type IdentityResolver interface {
  396	ID(ctx context.Context, obj *identity.Interface) (string, error)
  397	HumanID(ctx context.Context, obj *identity.Interface) (string, error)
  398	Name(ctx context.Context, obj *identity.Interface) (*string, error)
  399	Email(ctx context.Context, obj *identity.Interface) (*string, error)
  400	Login(ctx context.Context, obj *identity.Interface) (*string, error)
  401	DisplayName(ctx context.Context, obj *identity.Interface) (string, error)
  402	AvatarURL(ctx context.Context, obj *identity.Interface) (*string, error)
  403	IsProtected(ctx context.Context, obj *identity.Interface) (bool, error)
  404}
  405type LabelResolver interface {
  406	Name(ctx context.Context, obj *bug.Label) (string, error)
  407	Color(ctx context.Context, obj *bug.Label) (*color.RGBA, error)
  408}
  409type LabelChangeOperationResolver interface {
  410	Date(ctx context.Context, obj *bug.LabelChangeOperation) (*time.Time, error)
  411}
  412type LabelChangeResultResolver interface {
  413	Status(ctx context.Context, obj *bug.LabelChangeResult) (models.LabelChangeStatus, error)
  414}
  415type LabelChangeTimelineItemResolver interface {
  416	Date(ctx context.Context, obj *bug.LabelChangeTimelineItem) (*time.Time, error)
  417}
  418type MutationResolver interface {
  419	NewBug(ctx context.Context, input models.NewBugInput) (*models.NewBugPayload, error)
  420	AddComment(ctx context.Context, input models.AddCommentInput) (*models.AddCommentPayload, error)
  421	ChangeLabels(ctx context.Context, input *models.ChangeLabelInput) (*models.ChangeLabelPayload, error)
  422	OpenBug(ctx context.Context, input models.OpenBugInput) (*models.OpenBugPayload, error)
  423	CloseBug(ctx context.Context, input models.CloseBugInput) (*models.CloseBugPayload, error)
  424	SetTitle(ctx context.Context, input models.SetTitleInput) (*models.SetTitlePayload, error)
  425	Commit(ctx context.Context, input models.CommitInput) (*models.CommitPayload, error)
  426	CommitAsNeeded(ctx context.Context, input models.CommitAsNeededInput) (*models.CommitAsNeededPayload, error)
  427}
  428type QueryResolver interface {
  429	DefaultRepository(ctx context.Context) (*models.Repository, error)
  430	Repository(ctx context.Context, ref string) (*models.Repository, error)
  431}
  432type RepositoryResolver interface {
  433	AllBugs(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int, query *string) (*models.BugConnection, error)
  434	Bug(ctx context.Context, obj *models.Repository, prefix string) (*bug.Snapshot, error)
  435	AllIdentities(ctx context.Context, obj *models.Repository, after *string, before *string, first *int, last *int) (*models.IdentityConnection, error)
  436	Identity(ctx context.Context, obj *models.Repository, prefix string) (identity.Interface, error)
  437	UserIdentity(ctx context.Context, obj *models.Repository) (identity.Interface, error)
  438	ValidLabels(ctx context.Context, obj *models.Repository) ([]bug.Label, error)
  439}
  440type SetStatusOperationResolver interface {
  441	Date(ctx context.Context, obj *bug.SetStatusOperation) (*time.Time, error)
  442	Status(ctx context.Context, obj *bug.SetStatusOperation) (models.Status, error)
  443}
  444type SetStatusTimelineItemResolver interface {
  445	Date(ctx context.Context, obj *bug.SetStatusTimelineItem) (*time.Time, error)
  446	Status(ctx context.Context, obj *bug.SetStatusTimelineItem) (models.Status, error)
  447}
  448type SetTitleOperationResolver interface {
  449	Date(ctx context.Context, obj *bug.SetTitleOperation) (*time.Time, error)
  450}
  451type SetTitleTimelineItemResolver interface {
  452	Date(ctx context.Context, obj *bug.SetTitleTimelineItem) (*time.Time, error)
  453}
  454
  455type executableSchema struct {
  456	resolvers  ResolverRoot
  457	directives DirectiveRoot
  458	complexity ComplexityRoot
  459}
  460
  461func (e *executableSchema) Schema() *ast.Schema {
  462	return parsedSchema
  463}
  464
  465func (e *executableSchema) Complexity(typeName, field string, childComplexity int, rawArgs map[string]interface{}) (int, bool) {
  466	ec := executionContext{nil, e}
  467	_ = ec
  468	switch typeName + "." + field {
  469
  470	case "AddCommentOperation.author":
  471		if e.complexity.AddCommentOperation.Author == nil {
  472			break
  473		}
  474
  475		return e.complexity.AddCommentOperation.Author(childComplexity), true
  476
  477	case "AddCommentOperation.date":
  478		if e.complexity.AddCommentOperation.Date == nil {
  479			break
  480		}
  481
  482		return e.complexity.AddCommentOperation.Date(childComplexity), true
  483
  484	case "AddCommentOperation.files":
  485		if e.complexity.AddCommentOperation.Files == nil {
  486			break
  487		}
  488
  489		return e.complexity.AddCommentOperation.Files(childComplexity), true
  490
  491	case "AddCommentOperation.hash":
  492		if e.complexity.AddCommentOperation.Hash == nil {
  493			break
  494		}
  495
  496		return e.complexity.AddCommentOperation.Hash(childComplexity), true
  497
  498	case "AddCommentOperation.message":
  499		if e.complexity.AddCommentOperation.Message == nil {
  500			break
  501		}
  502
  503		return e.complexity.AddCommentOperation.Message(childComplexity), true
  504
  505	case "AddCommentPayload.bug":
  506		if e.complexity.AddCommentPayload.Bug == nil {
  507			break
  508		}
  509
  510		return e.complexity.AddCommentPayload.Bug(childComplexity), true
  511
  512	case "AddCommentPayload.clientMutationId":
  513		if e.complexity.AddCommentPayload.ClientMutationID == nil {
  514			break
  515		}
  516
  517		return e.complexity.AddCommentPayload.ClientMutationID(childComplexity), true
  518
  519	case "AddCommentPayload.operation":
  520		if e.complexity.AddCommentPayload.Operation == nil {
  521			break
  522		}
  523
  524		return e.complexity.AddCommentPayload.Operation(childComplexity), true
  525
  526	case "AddCommentTimelineItem.author":
  527		if e.complexity.AddCommentTimelineItem.Author == nil {
  528			break
  529		}
  530
  531		return e.complexity.AddCommentTimelineItem.Author(childComplexity), true
  532
  533	case "AddCommentTimelineItem.createdAt":
  534		if e.complexity.AddCommentTimelineItem.CreatedAt == nil {
  535			break
  536		}
  537
  538		return e.complexity.AddCommentTimelineItem.CreatedAt(childComplexity), true
  539
  540	case "AddCommentTimelineItem.edited":
  541		if e.complexity.AddCommentTimelineItem.Edited == nil {
  542			break
  543		}
  544
  545		return e.complexity.AddCommentTimelineItem.Edited(childComplexity), true
  546
  547	case "AddCommentTimelineItem.files":
  548		if e.complexity.AddCommentTimelineItem.Files == nil {
  549			break
  550		}
  551
  552		return e.complexity.AddCommentTimelineItem.Files(childComplexity), true
  553
  554	case "AddCommentTimelineItem.hash":
  555		if e.complexity.AddCommentTimelineItem.Hash == nil {
  556			break
  557		}
  558
  559		return e.complexity.AddCommentTimelineItem.Hash(childComplexity), true
  560
  561	case "AddCommentTimelineItem.history":
  562		if e.complexity.AddCommentTimelineItem.History == nil {
  563			break
  564		}
  565
  566		return e.complexity.AddCommentTimelineItem.History(childComplexity), true
  567
  568	case "AddCommentTimelineItem.lastEdit":
  569		if e.complexity.AddCommentTimelineItem.LastEdit == nil {
  570			break
  571		}
  572
  573		return e.complexity.AddCommentTimelineItem.LastEdit(childComplexity), true
  574
  575	case "AddCommentTimelineItem.message":
  576		if e.complexity.AddCommentTimelineItem.Message == nil {
  577			break
  578		}
  579
  580		return e.complexity.AddCommentTimelineItem.Message(childComplexity), true
  581
  582	case "AddCommentTimelineItem.messageIsEmpty":
  583		if e.complexity.AddCommentTimelineItem.MessageIsEmpty == nil {
  584			break
  585		}
  586
  587		return e.complexity.AddCommentTimelineItem.MessageIsEmpty(childComplexity), true
  588
  589	case "Bug.actors":
  590		if e.complexity.Bug.Actors == nil {
  591			break
  592		}
  593
  594		args, err := ec.field_Bug_actors_args(context.TODO(), rawArgs)
  595		if err != nil {
  596			return 0, false
  597		}
  598
  599		return e.complexity.Bug.Actors(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
  600
  601	case "Bug.author":
  602		if e.complexity.Bug.Author == nil {
  603			break
  604		}
  605
  606		return e.complexity.Bug.Author(childComplexity), true
  607
  608	case "Bug.comments":
  609		if e.complexity.Bug.Comments == nil {
  610			break
  611		}
  612
  613		args, err := ec.field_Bug_comments_args(context.TODO(), rawArgs)
  614		if err != nil {
  615			return 0, false
  616		}
  617
  618		return e.complexity.Bug.Comments(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
  619
  620	case "Bug.createdAt":
  621		if e.complexity.Bug.CreatedAt == nil {
  622			break
  623		}
  624
  625		return e.complexity.Bug.CreatedAt(childComplexity), true
  626
  627	case "Bug.humanId":
  628		if e.complexity.Bug.HumanId == nil {
  629			break
  630		}
  631
  632		return e.complexity.Bug.HumanId(childComplexity), true
  633
  634	case "Bug.id":
  635		if e.complexity.Bug.Id == nil {
  636			break
  637		}
  638
  639		return e.complexity.Bug.Id(childComplexity), true
  640
  641	case "Bug.labels":
  642		if e.complexity.Bug.Labels == nil {
  643			break
  644		}
  645
  646		return e.complexity.Bug.Labels(childComplexity), true
  647
  648	case "Bug.lastEdit":
  649		if e.complexity.Bug.LastEdit == nil {
  650			break
  651		}
  652
  653		return e.complexity.Bug.LastEdit(childComplexity), true
  654
  655	case "Bug.operations":
  656		if e.complexity.Bug.Operations == nil {
  657			break
  658		}
  659
  660		args, err := ec.field_Bug_operations_args(context.TODO(), rawArgs)
  661		if err != nil {
  662			return 0, false
  663		}
  664
  665		return e.complexity.Bug.Operations(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
  666
  667	case "Bug.participants":
  668		if e.complexity.Bug.Participants == nil {
  669			break
  670		}
  671
  672		args, err := ec.field_Bug_participants_args(context.TODO(), rawArgs)
  673		if err != nil {
  674			return 0, false
  675		}
  676
  677		return e.complexity.Bug.Participants(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
  678
  679	case "Bug.status":
  680		if e.complexity.Bug.Status == nil {
  681			break
  682		}
  683
  684		return e.complexity.Bug.Status(childComplexity), true
  685
  686	case "Bug.timeline":
  687		if e.complexity.Bug.Timeline == nil {
  688			break
  689		}
  690
  691		args, err := ec.field_Bug_timeline_args(context.TODO(), rawArgs)
  692		if err != nil {
  693			return 0, false
  694		}
  695
  696		return e.complexity.Bug.Timeline(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
  697
  698	case "Bug.title":
  699		if e.complexity.Bug.Title == nil {
  700			break
  701		}
  702
  703		return e.complexity.Bug.Title(childComplexity), true
  704
  705	case "BugConnection.edges":
  706		if e.complexity.BugConnection.Edges == nil {
  707			break
  708		}
  709
  710		return e.complexity.BugConnection.Edges(childComplexity), true
  711
  712	case "BugConnection.nodes":
  713		if e.complexity.BugConnection.Nodes == nil {
  714			break
  715		}
  716
  717		return e.complexity.BugConnection.Nodes(childComplexity), true
  718
  719	case "BugConnection.pageInfo":
  720		if e.complexity.BugConnection.PageInfo == nil {
  721			break
  722		}
  723
  724		return e.complexity.BugConnection.PageInfo(childComplexity), true
  725
  726	case "BugConnection.totalCount":
  727		if e.complexity.BugConnection.TotalCount == nil {
  728			break
  729		}
  730
  731		return e.complexity.BugConnection.TotalCount(childComplexity), true
  732
  733	case "BugEdge.cursor":
  734		if e.complexity.BugEdge.Cursor == nil {
  735			break
  736		}
  737
  738		return e.complexity.BugEdge.Cursor(childComplexity), true
  739
  740	case "BugEdge.node":
  741		if e.complexity.BugEdge.Node == nil {
  742			break
  743		}
  744
  745		return e.complexity.BugEdge.Node(childComplexity), true
  746
  747	case "ChangeLabelPayload.bug":
  748		if e.complexity.ChangeLabelPayload.Bug == nil {
  749			break
  750		}
  751
  752		return e.complexity.ChangeLabelPayload.Bug(childComplexity), true
  753
  754	case "ChangeLabelPayload.clientMutationId":
  755		if e.complexity.ChangeLabelPayload.ClientMutationID == nil {
  756			break
  757		}
  758
  759		return e.complexity.ChangeLabelPayload.ClientMutationID(childComplexity), true
  760
  761	case "ChangeLabelPayload.operation":
  762		if e.complexity.ChangeLabelPayload.Operation == nil {
  763			break
  764		}
  765
  766		return e.complexity.ChangeLabelPayload.Operation(childComplexity), true
  767
  768	case "ChangeLabelPayload.results":
  769		if e.complexity.ChangeLabelPayload.Results == nil {
  770			break
  771		}
  772
  773		return e.complexity.ChangeLabelPayload.Results(childComplexity), true
  774
  775	case "CloseBugPayload.bug":
  776		if e.complexity.CloseBugPayload.Bug == nil {
  777			break
  778		}
  779
  780		return e.complexity.CloseBugPayload.Bug(childComplexity), true
  781
  782	case "CloseBugPayload.clientMutationId":
  783		if e.complexity.CloseBugPayload.ClientMutationID == nil {
  784			break
  785		}
  786
  787		return e.complexity.CloseBugPayload.ClientMutationID(childComplexity), true
  788
  789	case "CloseBugPayload.operation":
  790		if e.complexity.CloseBugPayload.Operation == nil {
  791			break
  792		}
  793
  794		return e.complexity.CloseBugPayload.Operation(childComplexity), true
  795
  796	case "Color.B":
  797		if e.complexity.Color.B == nil {
  798			break
  799		}
  800
  801		return e.complexity.Color.B(childComplexity), true
  802
  803	case "Color.G":
  804		if e.complexity.Color.G == nil {
  805			break
  806		}
  807
  808		return e.complexity.Color.G(childComplexity), true
  809
  810	case "Color.R":
  811		if e.complexity.Color.R == nil {
  812			break
  813		}
  814
  815		return e.complexity.Color.R(childComplexity), true
  816
  817	case "Comment.author":
  818		if e.complexity.Comment.Author == nil {
  819			break
  820		}
  821
  822		return e.complexity.Comment.Author(childComplexity), true
  823
  824	case "Comment.files":
  825		if e.complexity.Comment.Files == nil {
  826			break
  827		}
  828
  829		return e.complexity.Comment.Files(childComplexity), true
  830
  831	case "Comment.message":
  832		if e.complexity.Comment.Message == nil {
  833			break
  834		}
  835
  836		return e.complexity.Comment.Message(childComplexity), true
  837
  838	case "CommentConnection.edges":
  839		if e.complexity.CommentConnection.Edges == nil {
  840			break
  841		}
  842
  843		return e.complexity.CommentConnection.Edges(childComplexity), true
  844
  845	case "CommentConnection.nodes":
  846		if e.complexity.CommentConnection.Nodes == nil {
  847			break
  848		}
  849
  850		return e.complexity.CommentConnection.Nodes(childComplexity), true
  851
  852	case "CommentConnection.pageInfo":
  853		if e.complexity.CommentConnection.PageInfo == nil {
  854			break
  855		}
  856
  857		return e.complexity.CommentConnection.PageInfo(childComplexity), true
  858
  859	case "CommentConnection.totalCount":
  860		if e.complexity.CommentConnection.TotalCount == nil {
  861			break
  862		}
  863
  864		return e.complexity.CommentConnection.TotalCount(childComplexity), true
  865
  866	case "CommentEdge.cursor":
  867		if e.complexity.CommentEdge.Cursor == nil {
  868			break
  869		}
  870
  871		return e.complexity.CommentEdge.Cursor(childComplexity), true
  872
  873	case "CommentEdge.node":
  874		if e.complexity.CommentEdge.Node == nil {
  875			break
  876		}
  877
  878		return e.complexity.CommentEdge.Node(childComplexity), true
  879
  880	case "CommentHistoryStep.date":
  881		if e.complexity.CommentHistoryStep.Date == nil {
  882			break
  883		}
  884
  885		return e.complexity.CommentHistoryStep.Date(childComplexity), true
  886
  887	case "CommentHistoryStep.message":
  888		if e.complexity.CommentHistoryStep.Message == nil {
  889			break
  890		}
  891
  892		return e.complexity.CommentHistoryStep.Message(childComplexity), true
  893
  894	case "CommitAsNeededPayload.bug":
  895		if e.complexity.CommitAsNeededPayload.Bug == nil {
  896			break
  897		}
  898
  899		return e.complexity.CommitAsNeededPayload.Bug(childComplexity), true
  900
  901	case "CommitAsNeededPayload.clientMutationId":
  902		if e.complexity.CommitAsNeededPayload.ClientMutationID == nil {
  903			break
  904		}
  905
  906		return e.complexity.CommitAsNeededPayload.ClientMutationID(childComplexity), true
  907
  908	case "CommitPayload.bug":
  909		if e.complexity.CommitPayload.Bug == nil {
  910			break
  911		}
  912
  913		return e.complexity.CommitPayload.Bug(childComplexity), true
  914
  915	case "CommitPayload.clientMutationId":
  916		if e.complexity.CommitPayload.ClientMutationID == nil {
  917			break
  918		}
  919
  920		return e.complexity.CommitPayload.ClientMutationID(childComplexity), true
  921
  922	case "CreateOperation.author":
  923		if e.complexity.CreateOperation.Author == nil {
  924			break
  925		}
  926
  927		return e.complexity.CreateOperation.Author(childComplexity), true
  928
  929	case "CreateOperation.date":
  930		if e.complexity.CreateOperation.Date == nil {
  931			break
  932		}
  933
  934		return e.complexity.CreateOperation.Date(childComplexity), true
  935
  936	case "CreateOperation.files":
  937		if e.complexity.CreateOperation.Files == nil {
  938			break
  939		}
  940
  941		return e.complexity.CreateOperation.Files(childComplexity), true
  942
  943	case "CreateOperation.hash":
  944		if e.complexity.CreateOperation.Hash == nil {
  945			break
  946		}
  947
  948		return e.complexity.CreateOperation.Hash(childComplexity), true
  949
  950	case "CreateOperation.message":
  951		if e.complexity.CreateOperation.Message == nil {
  952			break
  953		}
  954
  955		return e.complexity.CreateOperation.Message(childComplexity), true
  956
  957	case "CreateOperation.title":
  958		if e.complexity.CreateOperation.Title == nil {
  959			break
  960		}
  961
  962		return e.complexity.CreateOperation.Title(childComplexity), true
  963
  964	case "CreateTimelineItem.author":
  965		if e.complexity.CreateTimelineItem.Author == nil {
  966			break
  967		}
  968
  969		return e.complexity.CreateTimelineItem.Author(childComplexity), true
  970
  971	case "CreateTimelineItem.createdAt":
  972		if e.complexity.CreateTimelineItem.CreatedAt == nil {
  973			break
  974		}
  975
  976		return e.complexity.CreateTimelineItem.CreatedAt(childComplexity), true
  977
  978	case "CreateTimelineItem.edited":
  979		if e.complexity.CreateTimelineItem.Edited == nil {
  980			break
  981		}
  982
  983		return e.complexity.CreateTimelineItem.Edited(childComplexity), true
  984
  985	case "CreateTimelineItem.files":
  986		if e.complexity.CreateTimelineItem.Files == nil {
  987			break
  988		}
  989
  990		return e.complexity.CreateTimelineItem.Files(childComplexity), true
  991
  992	case "CreateTimelineItem.hash":
  993		if e.complexity.CreateTimelineItem.Hash == nil {
  994			break
  995		}
  996
  997		return e.complexity.CreateTimelineItem.Hash(childComplexity), true
  998
  999	case "CreateTimelineItem.history":
 1000		if e.complexity.CreateTimelineItem.History == nil {
 1001			break
 1002		}
 1003
 1004		return e.complexity.CreateTimelineItem.History(childComplexity), true
 1005
 1006	case "CreateTimelineItem.lastEdit":
 1007		if e.complexity.CreateTimelineItem.LastEdit == nil {
 1008			break
 1009		}
 1010
 1011		return e.complexity.CreateTimelineItem.LastEdit(childComplexity), true
 1012
 1013	case "CreateTimelineItem.message":
 1014		if e.complexity.CreateTimelineItem.Message == nil {
 1015			break
 1016		}
 1017
 1018		return e.complexity.CreateTimelineItem.Message(childComplexity), true
 1019
 1020	case "CreateTimelineItem.messageIsEmpty":
 1021		if e.complexity.CreateTimelineItem.MessageIsEmpty == nil {
 1022			break
 1023		}
 1024
 1025		return e.complexity.CreateTimelineItem.MessageIsEmpty(childComplexity), true
 1026
 1027	case "EditCommentOperation.author":
 1028		if e.complexity.EditCommentOperation.Author == nil {
 1029			break
 1030		}
 1031
 1032		return e.complexity.EditCommentOperation.Author(childComplexity), true
 1033
 1034	case "EditCommentOperation.date":
 1035		if e.complexity.EditCommentOperation.Date == nil {
 1036			break
 1037		}
 1038
 1039		return e.complexity.EditCommentOperation.Date(childComplexity), true
 1040
 1041	case "EditCommentOperation.files":
 1042		if e.complexity.EditCommentOperation.Files == nil {
 1043			break
 1044		}
 1045
 1046		return e.complexity.EditCommentOperation.Files(childComplexity), true
 1047
 1048	case "EditCommentOperation.hash":
 1049		if e.complexity.EditCommentOperation.Hash == nil {
 1050			break
 1051		}
 1052
 1053		return e.complexity.EditCommentOperation.Hash(childComplexity), true
 1054
 1055	case "EditCommentOperation.message":
 1056		if e.complexity.EditCommentOperation.Message == nil {
 1057			break
 1058		}
 1059
 1060		return e.complexity.EditCommentOperation.Message(childComplexity), true
 1061
 1062	case "EditCommentOperation.target":
 1063		if e.complexity.EditCommentOperation.Target == nil {
 1064			break
 1065		}
 1066
 1067		return e.complexity.EditCommentOperation.Target(childComplexity), true
 1068
 1069	case "Identity.avatarUrl":
 1070		if e.complexity.Identity.AvatarURL == nil {
 1071			break
 1072		}
 1073
 1074		return e.complexity.Identity.AvatarURL(childComplexity), true
 1075
 1076	case "Identity.displayName":
 1077		if e.complexity.Identity.DisplayName == nil {
 1078			break
 1079		}
 1080
 1081		return e.complexity.Identity.DisplayName(childComplexity), true
 1082
 1083	case "Identity.email":
 1084		if e.complexity.Identity.Email == nil {
 1085			break
 1086		}
 1087
 1088		return e.complexity.Identity.Email(childComplexity), true
 1089
 1090	case "Identity.humanId":
 1091		if e.complexity.Identity.HumanID == nil {
 1092			break
 1093		}
 1094
 1095		return e.complexity.Identity.HumanID(childComplexity), true
 1096
 1097	case "Identity.id":
 1098		if e.complexity.Identity.ID == nil {
 1099			break
 1100		}
 1101
 1102		return e.complexity.Identity.ID(childComplexity), true
 1103
 1104	case "Identity.isProtected":
 1105		if e.complexity.Identity.IsProtected == nil {
 1106			break
 1107		}
 1108
 1109		return e.complexity.Identity.IsProtected(childComplexity), true
 1110
 1111	case "Identity.login":
 1112		if e.complexity.Identity.Login == nil {
 1113			break
 1114		}
 1115
 1116		return e.complexity.Identity.Login(childComplexity), true
 1117
 1118	case "Identity.name":
 1119		if e.complexity.Identity.Name == nil {
 1120			break
 1121		}
 1122
 1123		return e.complexity.Identity.Name(childComplexity), true
 1124
 1125	case "IdentityConnection.edges":
 1126		if e.complexity.IdentityConnection.Edges == nil {
 1127			break
 1128		}
 1129
 1130		return e.complexity.IdentityConnection.Edges(childComplexity), true
 1131
 1132	case "IdentityConnection.nodes":
 1133		if e.complexity.IdentityConnection.Nodes == nil {
 1134			break
 1135		}
 1136
 1137		return e.complexity.IdentityConnection.Nodes(childComplexity), true
 1138
 1139	case "IdentityConnection.pageInfo":
 1140		if e.complexity.IdentityConnection.PageInfo == nil {
 1141			break
 1142		}
 1143
 1144		return e.complexity.IdentityConnection.PageInfo(childComplexity), true
 1145
 1146	case "IdentityConnection.totalCount":
 1147		if e.complexity.IdentityConnection.TotalCount == nil {
 1148			break
 1149		}
 1150
 1151		return e.complexity.IdentityConnection.TotalCount(childComplexity), true
 1152
 1153	case "IdentityEdge.cursor":
 1154		if e.complexity.IdentityEdge.Cursor == nil {
 1155			break
 1156		}
 1157
 1158		return e.complexity.IdentityEdge.Cursor(childComplexity), true
 1159
 1160	case "IdentityEdge.node":
 1161		if e.complexity.IdentityEdge.Node == nil {
 1162			break
 1163		}
 1164
 1165		return e.complexity.IdentityEdge.Node(childComplexity), true
 1166
 1167	case "Label.color":
 1168		if e.complexity.Label.Color == nil {
 1169			break
 1170		}
 1171
 1172		return e.complexity.Label.Color(childComplexity), true
 1173
 1174	case "Label.name":
 1175		if e.complexity.Label.Name == nil {
 1176			break
 1177		}
 1178
 1179		return e.complexity.Label.Name(childComplexity), true
 1180
 1181	case "LabelChangeOperation.added":
 1182		if e.complexity.LabelChangeOperation.Added == nil {
 1183			break
 1184		}
 1185
 1186		return e.complexity.LabelChangeOperation.Added(childComplexity), true
 1187
 1188	case "LabelChangeOperation.author":
 1189		if e.complexity.LabelChangeOperation.Author == nil {
 1190			break
 1191		}
 1192
 1193		return e.complexity.LabelChangeOperation.Author(childComplexity), true
 1194
 1195	case "LabelChangeOperation.date":
 1196		if e.complexity.LabelChangeOperation.Date == nil {
 1197			break
 1198		}
 1199
 1200		return e.complexity.LabelChangeOperation.Date(childComplexity), true
 1201
 1202	case "LabelChangeOperation.hash":
 1203		if e.complexity.LabelChangeOperation.Hash == nil {
 1204			break
 1205		}
 1206
 1207		return e.complexity.LabelChangeOperation.Hash(childComplexity), true
 1208
 1209	case "LabelChangeOperation.removed":
 1210		if e.complexity.LabelChangeOperation.Removed == nil {
 1211			break
 1212		}
 1213
 1214		return e.complexity.LabelChangeOperation.Removed(childComplexity), true
 1215
 1216	case "LabelChangeResult.label":
 1217		if e.complexity.LabelChangeResult.Label == nil {
 1218			break
 1219		}
 1220
 1221		return e.complexity.LabelChangeResult.Label(childComplexity), true
 1222
 1223	case "LabelChangeResult.status":
 1224		if e.complexity.LabelChangeResult.Status == nil {
 1225			break
 1226		}
 1227
 1228		return e.complexity.LabelChangeResult.Status(childComplexity), true
 1229
 1230	case "LabelChangeTimelineItem.added":
 1231		if e.complexity.LabelChangeTimelineItem.Added == nil {
 1232			break
 1233		}
 1234
 1235		return e.complexity.LabelChangeTimelineItem.Added(childComplexity), true
 1236
 1237	case "LabelChangeTimelineItem.author":
 1238		if e.complexity.LabelChangeTimelineItem.Author == nil {
 1239			break
 1240		}
 1241
 1242		return e.complexity.LabelChangeTimelineItem.Author(childComplexity), true
 1243
 1244	case "LabelChangeTimelineItem.date":
 1245		if e.complexity.LabelChangeTimelineItem.Date == nil {
 1246			break
 1247		}
 1248
 1249		return e.complexity.LabelChangeTimelineItem.Date(childComplexity), true
 1250
 1251	case "LabelChangeTimelineItem.hash":
 1252		if e.complexity.LabelChangeTimelineItem.Hash == nil {
 1253			break
 1254		}
 1255
 1256		return e.complexity.LabelChangeTimelineItem.Hash(childComplexity), true
 1257
 1258	case "LabelChangeTimelineItem.removed":
 1259		if e.complexity.LabelChangeTimelineItem.Removed == nil {
 1260			break
 1261		}
 1262
 1263		return e.complexity.LabelChangeTimelineItem.Removed(childComplexity), true
 1264
 1265	case "Mutation.addComment":
 1266		if e.complexity.Mutation.AddComment == nil {
 1267			break
 1268		}
 1269
 1270		args, err := ec.field_Mutation_addComment_args(context.TODO(), rawArgs)
 1271		if err != nil {
 1272			return 0, false
 1273		}
 1274
 1275		return e.complexity.Mutation.AddComment(childComplexity, args["input"].(models.AddCommentInput)), true
 1276
 1277	case "Mutation.changeLabels":
 1278		if e.complexity.Mutation.ChangeLabels == nil {
 1279			break
 1280		}
 1281
 1282		args, err := ec.field_Mutation_changeLabels_args(context.TODO(), rawArgs)
 1283		if err != nil {
 1284			return 0, false
 1285		}
 1286
 1287		return e.complexity.Mutation.ChangeLabels(childComplexity, args["input"].(*models.ChangeLabelInput)), true
 1288
 1289	case "Mutation.closeBug":
 1290		if e.complexity.Mutation.CloseBug == nil {
 1291			break
 1292		}
 1293
 1294		args, err := ec.field_Mutation_closeBug_args(context.TODO(), rawArgs)
 1295		if err != nil {
 1296			return 0, false
 1297		}
 1298
 1299		return e.complexity.Mutation.CloseBug(childComplexity, args["input"].(models.CloseBugInput)), true
 1300
 1301	case "Mutation.commit":
 1302		if e.complexity.Mutation.Commit == nil {
 1303			break
 1304		}
 1305
 1306		args, err := ec.field_Mutation_commit_args(context.TODO(), rawArgs)
 1307		if err != nil {
 1308			return 0, false
 1309		}
 1310
 1311		return e.complexity.Mutation.Commit(childComplexity, args["input"].(models.CommitInput)), true
 1312
 1313	case "Mutation.commitAsNeeded":
 1314		if e.complexity.Mutation.CommitAsNeeded == nil {
 1315			break
 1316		}
 1317
 1318		args, err := ec.field_Mutation_commitAsNeeded_args(context.TODO(), rawArgs)
 1319		if err != nil {
 1320			return 0, false
 1321		}
 1322
 1323		return e.complexity.Mutation.CommitAsNeeded(childComplexity, args["input"].(models.CommitAsNeededInput)), true
 1324
 1325	case "Mutation.newBug":
 1326		if e.complexity.Mutation.NewBug == nil {
 1327			break
 1328		}
 1329
 1330		args, err := ec.field_Mutation_newBug_args(context.TODO(), rawArgs)
 1331		if err != nil {
 1332			return 0, false
 1333		}
 1334
 1335		return e.complexity.Mutation.NewBug(childComplexity, args["input"].(models.NewBugInput)), true
 1336
 1337	case "Mutation.openBug":
 1338		if e.complexity.Mutation.OpenBug == nil {
 1339			break
 1340		}
 1341
 1342		args, err := ec.field_Mutation_openBug_args(context.TODO(), rawArgs)
 1343		if err != nil {
 1344			return 0, false
 1345		}
 1346
 1347		return e.complexity.Mutation.OpenBug(childComplexity, args["input"].(models.OpenBugInput)), true
 1348
 1349	case "Mutation.setTitle":
 1350		if e.complexity.Mutation.SetTitle == nil {
 1351			break
 1352		}
 1353
 1354		args, err := ec.field_Mutation_setTitle_args(context.TODO(), rawArgs)
 1355		if err != nil {
 1356			return 0, false
 1357		}
 1358
 1359		return e.complexity.Mutation.SetTitle(childComplexity, args["input"].(models.SetTitleInput)), true
 1360
 1361	case "NewBugPayload.bug":
 1362		if e.complexity.NewBugPayload.Bug == nil {
 1363			break
 1364		}
 1365
 1366		return e.complexity.NewBugPayload.Bug(childComplexity), true
 1367
 1368	case "NewBugPayload.clientMutationId":
 1369		if e.complexity.NewBugPayload.ClientMutationID == nil {
 1370			break
 1371		}
 1372
 1373		return e.complexity.NewBugPayload.ClientMutationID(childComplexity), true
 1374
 1375	case "NewBugPayload.operation":
 1376		if e.complexity.NewBugPayload.Operation == nil {
 1377			break
 1378		}
 1379
 1380		return e.complexity.NewBugPayload.Operation(childComplexity), true
 1381
 1382	case "OpenBugPayload.bug":
 1383		if e.complexity.OpenBugPayload.Bug == nil {
 1384			break
 1385		}
 1386
 1387		return e.complexity.OpenBugPayload.Bug(childComplexity), true
 1388
 1389	case "OpenBugPayload.clientMutationId":
 1390		if e.complexity.OpenBugPayload.ClientMutationID == nil {
 1391			break
 1392		}
 1393
 1394		return e.complexity.OpenBugPayload.ClientMutationID(childComplexity), true
 1395
 1396	case "OpenBugPayload.operation":
 1397		if e.complexity.OpenBugPayload.Operation == nil {
 1398			break
 1399		}
 1400
 1401		return e.complexity.OpenBugPayload.Operation(childComplexity), true
 1402
 1403	case "OperationConnection.edges":
 1404		if e.complexity.OperationConnection.Edges == nil {
 1405			break
 1406		}
 1407
 1408		return e.complexity.OperationConnection.Edges(childComplexity), true
 1409
 1410	case "OperationConnection.nodes":
 1411		if e.complexity.OperationConnection.Nodes == nil {
 1412			break
 1413		}
 1414
 1415		return e.complexity.OperationConnection.Nodes(childComplexity), true
 1416
 1417	case "OperationConnection.pageInfo":
 1418		if e.complexity.OperationConnection.PageInfo == nil {
 1419			break
 1420		}
 1421
 1422		return e.complexity.OperationConnection.PageInfo(childComplexity), true
 1423
 1424	case "OperationConnection.totalCount":
 1425		if e.complexity.OperationConnection.TotalCount == nil {
 1426			break
 1427		}
 1428
 1429		return e.complexity.OperationConnection.TotalCount(childComplexity), true
 1430
 1431	case "OperationEdge.cursor":
 1432		if e.complexity.OperationEdge.Cursor == nil {
 1433			break
 1434		}
 1435
 1436		return e.complexity.OperationEdge.Cursor(childComplexity), true
 1437
 1438	case "OperationEdge.node":
 1439		if e.complexity.OperationEdge.Node == nil {
 1440			break
 1441		}
 1442
 1443		return e.complexity.OperationEdge.Node(childComplexity), true
 1444
 1445	case "PageInfo.endCursor":
 1446		if e.complexity.PageInfo.EndCursor == nil {
 1447			break
 1448		}
 1449
 1450		return e.complexity.PageInfo.EndCursor(childComplexity), true
 1451
 1452	case "PageInfo.hasNextPage":
 1453		if e.complexity.PageInfo.HasNextPage == nil {
 1454			break
 1455		}
 1456
 1457		return e.complexity.PageInfo.HasNextPage(childComplexity), true
 1458
 1459	case "PageInfo.hasPreviousPage":
 1460		if e.complexity.PageInfo.HasPreviousPage == nil {
 1461			break
 1462		}
 1463
 1464		return e.complexity.PageInfo.HasPreviousPage(childComplexity), true
 1465
 1466	case "PageInfo.startCursor":
 1467		if e.complexity.PageInfo.StartCursor == nil {
 1468			break
 1469		}
 1470
 1471		return e.complexity.PageInfo.StartCursor(childComplexity), true
 1472
 1473	case "Query.defaultRepository":
 1474		if e.complexity.Query.DefaultRepository == nil {
 1475			break
 1476		}
 1477
 1478		return e.complexity.Query.DefaultRepository(childComplexity), true
 1479
 1480	case "Query.repository":
 1481		if e.complexity.Query.Repository == nil {
 1482			break
 1483		}
 1484
 1485		args, err := ec.field_Query_repository_args(context.TODO(), rawArgs)
 1486		if err != nil {
 1487			return 0, false
 1488		}
 1489
 1490		return e.complexity.Query.Repository(childComplexity, args["ref"].(string)), true
 1491
 1492	case "Repository.allBugs":
 1493		if e.complexity.Repository.AllBugs == nil {
 1494			break
 1495		}
 1496
 1497		args, err := ec.field_Repository_allBugs_args(context.TODO(), rawArgs)
 1498		if err != nil {
 1499			return 0, false
 1500		}
 1501
 1502		return e.complexity.Repository.AllBugs(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int), args["query"].(*string)), true
 1503
 1504	case "Repository.allIdentities":
 1505		if e.complexity.Repository.AllIdentities == nil {
 1506			break
 1507		}
 1508
 1509		args, err := ec.field_Repository_allIdentities_args(context.TODO(), rawArgs)
 1510		if err != nil {
 1511			return 0, false
 1512		}
 1513
 1514		return e.complexity.Repository.AllIdentities(childComplexity, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int)), true
 1515
 1516	case "Repository.bug":
 1517		if e.complexity.Repository.Bug == nil {
 1518			break
 1519		}
 1520
 1521		args, err := ec.field_Repository_bug_args(context.TODO(), rawArgs)
 1522		if err != nil {
 1523			return 0, false
 1524		}
 1525
 1526		return e.complexity.Repository.Bug(childComplexity, args["prefix"].(string)), true
 1527
 1528	case "Repository.identity":
 1529		if e.complexity.Repository.Identity == nil {
 1530			break
 1531		}
 1532
 1533		args, err := ec.field_Repository_identity_args(context.TODO(), rawArgs)
 1534		if err != nil {
 1535			return 0, false
 1536		}
 1537
 1538		return e.complexity.Repository.Identity(childComplexity, args["prefix"].(string)), true
 1539
 1540	case "Repository.userIdentity":
 1541		if e.complexity.Repository.UserIdentity == nil {
 1542			break
 1543		}
 1544
 1545		return e.complexity.Repository.UserIdentity(childComplexity), true
 1546
 1547	case "Repository.validLabels":
 1548		if e.complexity.Repository.ValidLabels == nil {
 1549			break
 1550		}
 1551
 1552		return e.complexity.Repository.ValidLabels(childComplexity), true
 1553
 1554	case "SetStatusOperation.author":
 1555		if e.complexity.SetStatusOperation.Author == nil {
 1556			break
 1557		}
 1558
 1559		return e.complexity.SetStatusOperation.Author(childComplexity), true
 1560
 1561	case "SetStatusOperation.date":
 1562		if e.complexity.SetStatusOperation.Date == nil {
 1563			break
 1564		}
 1565
 1566		return e.complexity.SetStatusOperation.Date(childComplexity), true
 1567
 1568	case "SetStatusOperation.hash":
 1569		if e.complexity.SetStatusOperation.Hash == nil {
 1570			break
 1571		}
 1572
 1573		return e.complexity.SetStatusOperation.Hash(childComplexity), true
 1574
 1575	case "SetStatusOperation.status":
 1576		if e.complexity.SetStatusOperation.Status == nil {
 1577			break
 1578		}
 1579
 1580		return e.complexity.SetStatusOperation.Status(childComplexity), true
 1581
 1582	case "SetStatusTimelineItem.author":
 1583		if e.complexity.SetStatusTimelineItem.Author == nil {
 1584			break
 1585		}
 1586
 1587		return e.complexity.SetStatusTimelineItem.Author(childComplexity), true
 1588
 1589	case "SetStatusTimelineItem.date":
 1590		if e.complexity.SetStatusTimelineItem.Date == nil {
 1591			break
 1592		}
 1593
 1594		return e.complexity.SetStatusTimelineItem.Date(childComplexity), true
 1595
 1596	case "SetStatusTimelineItem.hash":
 1597		if e.complexity.SetStatusTimelineItem.Hash == nil {
 1598			break
 1599		}
 1600
 1601		return e.complexity.SetStatusTimelineItem.Hash(childComplexity), true
 1602
 1603	case "SetStatusTimelineItem.status":
 1604		if e.complexity.SetStatusTimelineItem.Status == nil {
 1605			break
 1606		}
 1607
 1608		return e.complexity.SetStatusTimelineItem.Status(childComplexity), true
 1609
 1610	case "SetTitleOperation.author":
 1611		if e.complexity.SetTitleOperation.Author == nil {
 1612			break
 1613		}
 1614
 1615		return e.complexity.SetTitleOperation.Author(childComplexity), true
 1616
 1617	case "SetTitleOperation.date":
 1618		if e.complexity.SetTitleOperation.Date == nil {
 1619			break
 1620		}
 1621
 1622		return e.complexity.SetTitleOperation.Date(childComplexity), true
 1623
 1624	case "SetTitleOperation.hash":
 1625		if e.complexity.SetTitleOperation.Hash == nil {
 1626			break
 1627		}
 1628
 1629		return e.complexity.SetTitleOperation.Hash(childComplexity), true
 1630
 1631	case "SetTitleOperation.title":
 1632		if e.complexity.SetTitleOperation.Title == nil {
 1633			break
 1634		}
 1635
 1636		return e.complexity.SetTitleOperation.Title(childComplexity), true
 1637
 1638	case "SetTitleOperation.was":
 1639		if e.complexity.SetTitleOperation.Was == nil {
 1640			break
 1641		}
 1642
 1643		return e.complexity.SetTitleOperation.Was(childComplexity), true
 1644
 1645	case "SetTitlePayload.bug":
 1646		if e.complexity.SetTitlePayload.Bug == nil {
 1647			break
 1648		}
 1649
 1650		return e.complexity.SetTitlePayload.Bug(childComplexity), true
 1651
 1652	case "SetTitlePayload.clientMutationId":
 1653		if e.complexity.SetTitlePayload.ClientMutationID == nil {
 1654			break
 1655		}
 1656
 1657		return e.complexity.SetTitlePayload.ClientMutationID(childComplexity), true
 1658
 1659	case "SetTitlePayload.operation":
 1660		if e.complexity.SetTitlePayload.Operation == nil {
 1661			break
 1662		}
 1663
 1664		return e.complexity.SetTitlePayload.Operation(childComplexity), true
 1665
 1666	case "SetTitleTimelineItem.author":
 1667		if e.complexity.SetTitleTimelineItem.Author == nil {
 1668			break
 1669		}
 1670
 1671		return e.complexity.SetTitleTimelineItem.Author(childComplexity), true
 1672
 1673	case "SetTitleTimelineItem.date":
 1674		if e.complexity.SetTitleTimelineItem.Date == nil {
 1675			break
 1676		}
 1677
 1678		return e.complexity.SetTitleTimelineItem.Date(childComplexity), true
 1679
 1680	case "SetTitleTimelineItem.hash":
 1681		if e.complexity.SetTitleTimelineItem.Hash == nil {
 1682			break
 1683		}
 1684
 1685		return e.complexity.SetTitleTimelineItem.Hash(childComplexity), true
 1686
 1687	case "SetTitleTimelineItem.title":
 1688		if e.complexity.SetTitleTimelineItem.Title == nil {
 1689			break
 1690		}
 1691
 1692		return e.complexity.SetTitleTimelineItem.Title(childComplexity), true
 1693
 1694	case "SetTitleTimelineItem.was":
 1695		if e.complexity.SetTitleTimelineItem.Was == nil {
 1696			break
 1697		}
 1698
 1699		return e.complexity.SetTitleTimelineItem.Was(childComplexity), true
 1700
 1701	case "TimelineItemConnection.edges":
 1702		if e.complexity.TimelineItemConnection.Edges == nil {
 1703			break
 1704		}
 1705
 1706		return e.complexity.TimelineItemConnection.Edges(childComplexity), true
 1707
 1708	case "TimelineItemConnection.nodes":
 1709		if e.complexity.TimelineItemConnection.Nodes == nil {
 1710			break
 1711		}
 1712
 1713		return e.complexity.TimelineItemConnection.Nodes(childComplexity), true
 1714
 1715	case "TimelineItemConnection.pageInfo":
 1716		if e.complexity.TimelineItemConnection.PageInfo == nil {
 1717			break
 1718		}
 1719
 1720		return e.complexity.TimelineItemConnection.PageInfo(childComplexity), true
 1721
 1722	case "TimelineItemConnection.totalCount":
 1723		if e.complexity.TimelineItemConnection.TotalCount == nil {
 1724			break
 1725		}
 1726
 1727		return e.complexity.TimelineItemConnection.TotalCount(childComplexity), true
 1728
 1729	case "TimelineItemEdge.cursor":
 1730		if e.complexity.TimelineItemEdge.Cursor == nil {
 1731			break
 1732		}
 1733
 1734		return e.complexity.TimelineItemEdge.Cursor(childComplexity), true
 1735
 1736	case "TimelineItemEdge.node":
 1737		if e.complexity.TimelineItemEdge.Node == nil {
 1738			break
 1739		}
 1740
 1741		return e.complexity.TimelineItemEdge.Node(childComplexity), true
 1742
 1743	}
 1744	return 0, false
 1745}
 1746
 1747func (e *executableSchema) Query(ctx context.Context, op *ast.OperationDefinition) *graphql.Response {
 1748	ec := executionContext{graphql.GetRequestContext(ctx), e}
 1749
 1750	buf := ec.RequestMiddleware(ctx, func(ctx context.Context) []byte {
 1751		data := ec._Query(ctx, op.SelectionSet)
 1752		var buf bytes.Buffer
 1753		data.MarshalGQL(&buf)
 1754		return buf.Bytes()
 1755	})
 1756
 1757	return &graphql.Response{
 1758		Data:       buf,
 1759		Errors:     ec.Errors,
 1760		Extensions: ec.Extensions,
 1761	}
 1762}
 1763
 1764func (e *executableSchema) Mutation(ctx context.Context, op *ast.OperationDefinition) *graphql.Response {
 1765	ec := executionContext{graphql.GetRequestContext(ctx), e}
 1766
 1767	buf := ec.RequestMiddleware(ctx, func(ctx context.Context) []byte {
 1768		data := ec._Mutation(ctx, op.SelectionSet)
 1769		var buf bytes.Buffer
 1770		data.MarshalGQL(&buf)
 1771		return buf.Bytes()
 1772	})
 1773
 1774	return &graphql.Response{
 1775		Data:       buf,
 1776		Errors:     ec.Errors,
 1777		Extensions: ec.Extensions,
 1778	}
 1779}
 1780
 1781func (e *executableSchema) Subscription(ctx context.Context, op *ast.OperationDefinition) func() *graphql.Response {
 1782	return graphql.OneShot(graphql.ErrorResponse(ctx, "subscriptions are not supported"))
 1783}
 1784
 1785type executionContext struct {
 1786	*graphql.RequestContext
 1787	*executableSchema
 1788}
 1789
 1790func (ec *executionContext) introspectSchema() (*introspection.Schema, error) {
 1791	if ec.DisableIntrospection {
 1792		return nil, errors.New("introspection disabled")
 1793	}
 1794	return introspection.WrapSchema(parsedSchema), nil
 1795}
 1796
 1797func (ec *executionContext) introspectType(name string) (*introspection.Type, error) {
 1798	if ec.DisableIntrospection {
 1799		return nil, errors.New("introspection disabled")
 1800	}
 1801	return introspection.WrapTypeFromDef(parsedSchema, parsedSchema.Types[name]), nil
 1802}
 1803
 1804var parsedSchema = gqlparser.MustLoadSchema(
 1805	&ast.Source{Name: "schema/bug.graphql", Input: `"""Represents a comment on a bug."""
 1806type Comment implements Authored {
 1807  """The author of this comment."""
 1808  author: Identity!
 1809
 1810  """The message of this comment."""
 1811  message: String!
 1812
 1813  """All media's hash referenced in this comment"""
 1814  files: [Hash!]!
 1815}
 1816
 1817type CommentConnection {
 1818  edges: [CommentEdge!]!
 1819  nodes: [Comment!]!
 1820  pageInfo: PageInfo!
 1821  totalCount: Int!
 1822}
 1823
 1824type CommentEdge {
 1825  cursor: String!
 1826  node: Comment!
 1827}
 1828
 1829enum Status {
 1830  OPEN
 1831  CLOSED
 1832}
 1833
 1834type Bug implements Authored {
 1835  """The identifier for this bug"""
 1836  id: String!
 1837  """The human version (truncated) identifier for this bug"""
 1838  humanId: String!
 1839  status: Status!
 1840  title: String!
 1841  labels: [Label!]!
 1842  author: Identity!
 1843  createdAt: Time!
 1844  lastEdit: Time!
 1845
 1846  """The actors of the bug. Actors are Identity that have interacted with the bug."""
 1847  actors(
 1848    """Returns the elements in the list that come after the specified cursor."""
 1849    after: String
 1850    """Returns the elements in the list that come before the specified cursor."""
 1851    before: String
 1852    """Returns the first _n_ elements from the list."""
 1853    first: Int
 1854    """Returns the last _n_ elements from the list."""
 1855    last: Int
 1856  ): IdentityConnection!
 1857
 1858  """The participants of the bug. Participants are Identity that have created or
 1859  added a comment on the bug."""
 1860  participants(
 1861    """Returns the elements in the list that come after the specified cursor."""
 1862    after: String
 1863    """Returns the elements in the list that come before the specified cursor."""
 1864    before: String
 1865    """Returns the first _n_ elements from the list."""
 1866    first: Int
 1867    """Returns the last _n_ elements from the list."""
 1868    last: Int
 1869  ): IdentityConnection!
 1870
 1871  comments(
 1872    """Returns the elements in the list that come after the specified cursor."""
 1873    after: String
 1874    """Returns the elements in the list that come before the specified cursor."""
 1875    before: String
 1876    """Returns the first _n_ elements from the list."""
 1877    first: Int
 1878    """Returns the last _n_ elements from the list."""
 1879    last: Int
 1880  ): CommentConnection!
 1881
 1882  timeline(
 1883    """Returns the elements in the list that come after the specified cursor."""
 1884    after: String
 1885    """Returns the elements in the list that come before the specified cursor."""
 1886    before: String
 1887    """Returns the first _n_ elements from the list."""
 1888    first: Int
 1889    """Returns the last _n_ elements from the list."""
 1890    last: Int
 1891  ): TimelineItemConnection!
 1892
 1893  operations(
 1894    """Returns the elements in the list that come after the specified cursor."""
 1895    after: String
 1896    """Returns the elements in the list that come before the specified cursor."""
 1897    before: String
 1898    """Returns the first _n_ elements from the list."""
 1899    first: Int
 1900    """Returns the last _n_ elements from the list."""
 1901    last: Int
 1902  ): OperationConnection!
 1903}
 1904
 1905"""The connection type for Bug."""
 1906type BugConnection {
 1907  """A list of edges."""
 1908  edges: [BugEdge!]!
 1909  nodes: [Bug!]!
 1910  """Information to aid in pagination."""
 1911  pageInfo: PageInfo!
 1912  """Identifies the total count of items in the connection."""
 1913  totalCount: Int!
 1914}
 1915
 1916"""An edge in a connection."""
 1917type BugEdge {
 1918  """A cursor for use in pagination."""
 1919  cursor: String!
 1920  """The item at the end of the edge."""
 1921  node: Bug!
 1922}
 1923`},
 1924	&ast.Source{Name: "schema/identity.graphql", Input: `"""Represents an identity"""
 1925type Identity {
 1926    """The identifier for this identity"""
 1927    id: String!
 1928    """The human version (truncated) identifier for this identity"""
 1929    humanId: String!
 1930    """The name of the person, if known."""
 1931    name: String
 1932    """The email of the person, if known."""
 1933    email: String
 1934    """The login of the person, if known."""
 1935    login: String
 1936    """A string containing the either the name of the person, its login or both"""
 1937    displayName: String!
 1938    """An url to an avatar"""
 1939    avatarUrl: String
 1940    """isProtected is true if the chain of git commits started to be signed.
 1941    If that's the case, only signed commit with a valid key for this identity can be added."""
 1942    isProtected: Boolean!
 1943}
 1944
 1945type IdentityConnection {
 1946    edges: [IdentityEdge!]!
 1947    nodes: [Identity!]!
 1948    pageInfo: PageInfo!
 1949    totalCount: Int!
 1950}
 1951
 1952type IdentityEdge {
 1953    cursor: String!
 1954    node: Identity!
 1955}`},
 1956	&ast.Source{Name: "schema/mutations.graphql", Input: `input NewBugInput {
 1957    """A unique identifier for the client performing the mutation."""
 1958    clientMutationId: String
 1959    """"The name of the repository. If not set, the default repository is used."""
 1960    repoRef: String
 1961    """The title of the new bug."""
 1962    title: String!
 1963    """The first message of the new bug."""
 1964    message: String!
 1965    """The collection of file's hash required for the first message."""
 1966    files: [Hash!]
 1967}
 1968
 1969type NewBugPayload {
 1970    """A unique identifier for the client performing the mutation."""
 1971    clientMutationId: String
 1972    """The created bug."""
 1973    bug: Bug!
 1974    """The resulting operation."""
 1975    operation: CreateOperation!
 1976}
 1977
 1978input AddCommentInput {
 1979    """A unique identifier for the client performing the mutation."""
 1980    clientMutationId: String
 1981    """"The name of the repository. If not set, the default repository is used."""
 1982    repoRef: String
 1983    """The bug ID's prefix."""
 1984    prefix: String!
 1985    """The first message of the new bug."""
 1986    message: String!
 1987    """The collection of file's hash required for the first message."""
 1988    files: [Hash!]
 1989}
 1990
 1991type AddCommentPayload {
 1992    """A unique identifier for the client performing the mutation."""
 1993    clientMutationId: String
 1994    """The affected bug."""
 1995    bug: Bug!
 1996    """The resulting operation."""
 1997    operation: AddCommentOperation!
 1998}
 1999
 2000input ChangeLabelInput {
 2001    """A unique identifier for the client performing the mutation."""
 2002    clientMutationId: String
 2003    """"The name of the repository. If not set, the default repository is used."""
 2004    repoRef: String
 2005    """The bug ID's prefix."""
 2006    prefix: String!
 2007    """The list of label to add."""
 2008    added: [String!]
 2009    """The list of label to remove."""
 2010    Removed: [String!]
 2011}
 2012
 2013enum LabelChangeStatus {
 2014    ADDED
 2015    REMOVED
 2016    DUPLICATE_IN_OP
 2017    ALREADY_EXIST
 2018    DOESNT_EXIST
 2019}
 2020
 2021type LabelChangeResult {
 2022    """The source label."""
 2023    label: Label!
 2024    """The effect this label had."""
 2025    status: LabelChangeStatus!
 2026}
 2027
 2028type ChangeLabelPayload {
 2029    """A unique identifier for the client performing the mutation."""
 2030    clientMutationId: String
 2031    """The affected bug."""
 2032    bug: Bug!
 2033    """The resulting operation."""
 2034    operation: LabelChangeOperation!
 2035    """The effect each source label had."""
 2036    results: [LabelChangeResult]!
 2037}
 2038
 2039input OpenBugInput {
 2040    """A unique identifier for the client performing the mutation."""
 2041    clientMutationId: String
 2042    """"The name of the repository. If not set, the default repository is used."""
 2043    repoRef: String
 2044    """The bug ID's prefix."""
 2045    prefix: String!
 2046}
 2047
 2048type OpenBugPayload {
 2049    """A unique identifier for the client performing the mutation."""
 2050    clientMutationId: String
 2051    """The affected bug."""
 2052    bug: Bug!
 2053    """The resulting operation."""
 2054    operation: SetStatusOperation!
 2055}
 2056
 2057input CloseBugInput {
 2058    """A unique identifier for the client performing the mutation."""
 2059    clientMutationId: String
 2060    """"The name of the repository. If not set, the default repository is used."""
 2061    repoRef: String
 2062    """The bug ID's prefix."""
 2063    prefix: String!
 2064}
 2065
 2066type CloseBugPayload {
 2067    """A unique identifier for the client performing the mutation."""
 2068    clientMutationId: String
 2069    """The affected bug."""
 2070    bug: Bug!
 2071    """The resulting operation."""
 2072    operation: SetStatusOperation!
 2073}
 2074
 2075input SetTitleInput {
 2076    """A unique identifier for the client performing the mutation."""
 2077    clientMutationId: String
 2078    """"The name of the repository. If not set, the default repository is used."""
 2079    repoRef: String
 2080    """The bug ID's prefix."""
 2081    prefix: String!
 2082    """The new title."""
 2083    title: String!
 2084}
 2085
 2086type SetTitlePayload {
 2087    """A unique identifier for the client performing the mutation."""
 2088    clientMutationId: String
 2089    """The affected bug."""
 2090    bug: Bug!
 2091    """The resulting operation"""
 2092    operation: SetTitleOperation!
 2093}
 2094
 2095input CommitInput {
 2096    """A unique identifier for the client performing the mutation."""
 2097    clientMutationId: String
 2098    """"The name of the repository. If not set, the default repository is used."""
 2099    repoRef: String
 2100    """The bug ID's prefix."""
 2101    prefix: String!
 2102}
 2103
 2104type CommitPayload {
 2105    """A unique identifier for the client performing the mutation."""
 2106    clientMutationId: String
 2107    """The affected bug."""
 2108    bug: Bug!
 2109}
 2110
 2111input CommitAsNeededInput {
 2112    """A unique identifier for the client performing the mutation."""
 2113    clientMutationId: String
 2114    """"The name of the repository. If not set, the default repository is used."""
 2115    repoRef: String
 2116    """The bug ID's prefix."""
 2117    prefix: String!
 2118}
 2119
 2120type CommitAsNeededPayload {
 2121    """A unique identifier for the client performing the mutation."""
 2122    clientMutationId: String
 2123    """The affected bug."""
 2124    bug: Bug!
 2125}
 2126`},
 2127	&ast.Source{Name: "schema/operations.graphql", Input: `"""An operation applied to a bug."""
 2128interface Operation {
 2129    """The hash of the operation"""
 2130    hash: Hash!
 2131    """The operations author."""
 2132    author: Identity!
 2133    """The datetime when this operation was issued."""
 2134    date: Time!
 2135}
 2136
 2137# Connection
 2138
 2139"""The connection type for an Operation"""
 2140type OperationConnection {
 2141    edges: [OperationEdge!]!
 2142    nodes: [Operation!]!
 2143    pageInfo: PageInfo!
 2144    totalCount: Int!
 2145}
 2146
 2147"""Represent an Operation"""
 2148type OperationEdge {
 2149    cursor: String!
 2150    node: Operation!
 2151}
 2152
 2153# Operations
 2154
 2155type CreateOperation implements Operation & Authored {
 2156    """The hash of the operation"""
 2157    hash: Hash!
 2158    """The author of this object."""
 2159    author: Identity!
 2160    """The datetime when this operation was issued."""
 2161    date: Time!
 2162
 2163    title: String!
 2164    message: String!
 2165    files: [Hash!]!
 2166}
 2167
 2168type SetTitleOperation implements Operation & Authored {
 2169    """The hash of the operation"""
 2170    hash: Hash!
 2171    """The author of this object."""
 2172    author: Identity!
 2173    """The datetime when this operation was issued."""
 2174    date: Time!
 2175
 2176    title: String!
 2177    was: String!
 2178}
 2179
 2180type AddCommentOperation implements Operation & Authored {
 2181    """The hash of the operation"""
 2182    hash: Hash!
 2183    """The author of this object."""
 2184    author: Identity!
 2185    """The datetime when this operation was issued."""
 2186    date: Time!
 2187
 2188    message: String!
 2189    files: [Hash!]!
 2190}
 2191
 2192type EditCommentOperation implements Operation & Authored {
 2193    """The hash of the operation"""
 2194    hash: Hash!
 2195    """The author of this object."""
 2196    author: Identity!
 2197    """The datetime when this operation was issued."""
 2198    date: Time!
 2199
 2200    target: Hash!
 2201    message: String!
 2202    files: [Hash!]!
 2203}
 2204
 2205type SetStatusOperation implements Operation & Authored {
 2206    """The hash of the operation"""
 2207    hash: Hash!
 2208    """The author of this object."""
 2209    author: Identity!
 2210    """The datetime when this operation was issued."""
 2211    date: Time!
 2212
 2213    status: Status!
 2214}
 2215
 2216type LabelChangeOperation implements Operation & Authored {
 2217    """The hash of the operation"""
 2218    hash: Hash!
 2219    """The author of this object."""
 2220    author: Identity!
 2221    """The datetime when this operation was issued."""
 2222    date: Time!
 2223
 2224    added: [Label!]!
 2225    removed: [Label!]!
 2226}
 2227`},
 2228	&ast.Source{Name: "schema/repository.graphql", Input: `
 2229type Repository {
 2230    """All the bugs"""
 2231    allBugs(
 2232        """Returns the elements in the list that come after the specified cursor."""
 2233        after: String
 2234        """Returns the elements in the list that come before the specified cursor."""
 2235        before: String
 2236        """Returns the first _n_ elements from the list."""
 2237        first: Int
 2238        """Returns the last _n_ elements from the list."""
 2239        last: Int
 2240        """A query to select and order bugs"""
 2241        query: String
 2242    ): BugConnection!
 2243
 2244    bug(prefix: String!): Bug
 2245
 2246    """All the identities"""
 2247    allIdentities(
 2248        """Returns the elements in the list that come after the specified cursor."""
 2249        after: String
 2250        """Returns the elements in the list that come before the specified cursor."""
 2251        before: String
 2252        """Returns the first _n_ elements from the list."""
 2253        first: Int
 2254        """Returns the last _n_ elements from the list."""
 2255        last: Int
 2256    ): IdentityConnection!
 2257
 2258    identity(prefix: String!): Identity
 2259
 2260    """The identity created or selected by the user as its own"""
 2261    userIdentity: Identity
 2262
 2263    """List of valid labels."""
 2264    validLabels: [Label!]!
 2265}`},
 2266	&ast.Source{Name: "schema/root.graphql", Input: `type Query {
 2267    """The default unnamend repository."""
 2268    defaultRepository: Repository
 2269    """Access a repository by reference/name."""
 2270    repository(ref: String!): Repository
 2271}
 2272
 2273type Mutation {
 2274    """Create a new bug"""
 2275    newBug(input: NewBugInput!): NewBugPayload!
 2276    """Add a new comment to a bug"""
 2277    addComment(input: AddCommentInput!): AddCommentPayload!
 2278    """Add or remove a set of label on a bug"""
 2279    changeLabels(input: ChangeLabelInput): ChangeLabelPayload!
 2280    """Change a bug's status to open"""
 2281    openBug(input: OpenBugInput!): OpenBugPayload!
 2282    """Change a bug's status to closed"""
 2283    closeBug(input: CloseBugInput!): CloseBugPayload!
 2284    """Change a bug's title"""
 2285    setTitle(input: SetTitleInput!): SetTitlePayload!
 2286    """Commit write the pending operations into storage. This mutation fail if nothing is pending"""
 2287    commit(input: CommitInput!): CommitPayload!
 2288    """Commit write the pending operations into storage. This mutation succed if nothing is pending"""
 2289    commitAsNeeded(input: CommitAsNeededInput!): CommitAsNeededPayload!
 2290}
 2291`},
 2292	&ast.Source{Name: "schema/timeline.graphql", Input: `"""An item in the timeline of events"""
 2293interface TimelineItem {
 2294    """The hash of the source operation"""
 2295    hash: Hash!
 2296}
 2297
 2298"""CommentHistoryStep hold one version of a message in the history"""
 2299type CommentHistoryStep {
 2300    message: String!
 2301    date: Time!
 2302}
 2303
 2304# Connection
 2305
 2306"""The connection type for TimelineItem"""
 2307type TimelineItemConnection {
 2308    edges: [TimelineItemEdge!]!
 2309    nodes: [TimelineItem!]!
 2310    pageInfo: PageInfo!
 2311    totalCount: Int!
 2312}
 2313
 2314"""Represent a TimelineItem"""
 2315type TimelineItemEdge {
 2316    cursor: String!
 2317    node: TimelineItem!
 2318}
 2319
 2320# Items
 2321
 2322"""CreateTimelineItem is a TimelineItem that represent the creation of a bug and its message edition history"""
 2323type CreateTimelineItem implements TimelineItem & Authored {
 2324    """The hash of the source operation"""
 2325    hash: Hash!
 2326    author: Identity!
 2327    message: String!
 2328    messageIsEmpty: Boolean!
 2329    files: [Hash!]!
 2330    createdAt: Time!
 2331    lastEdit: Time!
 2332    edited: Boolean!
 2333    history: [CommentHistoryStep!]!
 2334}
 2335
 2336"""AddCommentTimelineItem is a TimelineItem that represent a Comment and its edition history"""
 2337type AddCommentTimelineItem implements TimelineItem & Authored {
 2338    """The hash of the source operation"""
 2339    hash: Hash!
 2340    author: Identity!
 2341    message: String!
 2342    messageIsEmpty: Boolean!
 2343    files: [Hash!]!
 2344    createdAt: Time!
 2345    lastEdit: Time!
 2346    edited: Boolean!
 2347    history: [CommentHistoryStep!]!
 2348}
 2349
 2350"""LabelChangeTimelineItem is a TimelineItem that represent a change in the labels of a bug"""
 2351type LabelChangeTimelineItem implements TimelineItem & Authored {
 2352    """The hash of the source operation"""
 2353    hash: Hash!
 2354    author: Identity!
 2355    date: Time!
 2356    added: [Label!]!
 2357    removed: [Label!]!
 2358}
 2359
 2360"""SetStatusTimelineItem is a TimelineItem that represent a change in the status of a bug"""
 2361type SetStatusTimelineItem implements TimelineItem & Authored {
 2362    """The hash of the source operation"""
 2363    hash: Hash!
 2364    author: Identity!
 2365    date: Time!
 2366    status: Status!
 2367}
 2368
 2369"""LabelChangeTimelineItem is a TimelineItem that represent a change in the title of a bug"""
 2370type SetTitleTimelineItem implements TimelineItem & Authored {
 2371    """The hash of the source operation"""
 2372    hash: Hash!
 2373    author: Identity!
 2374    date: Time!
 2375    title: String!
 2376    was: String!
 2377}
 2378`},
 2379	&ast.Source{Name: "schema/types.graphql", Input: `scalar Time
 2380scalar Hash
 2381
 2382"""Defines a color by red, green and blue components."""
 2383type Color {
 2384    """Red component of the color."""
 2385    R: Int!
 2386    """Green component of the color."""
 2387    G: Int!
 2388    """Blue component of the color."""
 2389    B: Int!
 2390}
 2391
 2392"""Label for a bug."""
 2393type Label {
 2394    """The name of the label."""
 2395    name: String!
 2396    """Color of the label."""
 2397    color: Color!
 2398}
 2399
 2400"""Information about pagination in a connection."""
 2401type PageInfo {
 2402    """When paginating forwards, are there more items?"""
 2403    hasNextPage: Boolean!
 2404    """When paginating backwards, are there more items?"""
 2405    hasPreviousPage: Boolean!
 2406    """When paginating backwards, the cursor to continue."""
 2407    startCursor: String!
 2408    """When paginating forwards, the cursor to continue."""
 2409    endCursor: String!
 2410}
 2411
 2412"""An object that has an author."""
 2413interface Authored {
 2414    """The author of this object."""
 2415    author: Identity!
 2416}
 2417`},
 2418)
 2419
 2420// endregion ************************** generated!.gotpl **************************
 2421
 2422// region    ***************************** args.gotpl *****************************
 2423
 2424func (ec *executionContext) field_Bug_actors_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2425	var err error
 2426	args := map[string]interface{}{}
 2427	var arg0 *string
 2428	if tmp, ok := rawArgs["after"]; ok {
 2429		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2430		if err != nil {
 2431			return nil, err
 2432		}
 2433	}
 2434	args["after"] = arg0
 2435	var arg1 *string
 2436	if tmp, ok := rawArgs["before"]; ok {
 2437		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2438		if err != nil {
 2439			return nil, err
 2440		}
 2441	}
 2442	args["before"] = arg1
 2443	var arg2 *int
 2444	if tmp, ok := rawArgs["first"]; ok {
 2445		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2446		if err != nil {
 2447			return nil, err
 2448		}
 2449	}
 2450	args["first"] = arg2
 2451	var arg3 *int
 2452	if tmp, ok := rawArgs["last"]; ok {
 2453		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2454		if err != nil {
 2455			return nil, err
 2456		}
 2457	}
 2458	args["last"] = arg3
 2459	return args, nil
 2460}
 2461
 2462func (ec *executionContext) field_Bug_comments_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2463	var err error
 2464	args := map[string]interface{}{}
 2465	var arg0 *string
 2466	if tmp, ok := rawArgs["after"]; ok {
 2467		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2468		if err != nil {
 2469			return nil, err
 2470		}
 2471	}
 2472	args["after"] = arg0
 2473	var arg1 *string
 2474	if tmp, ok := rawArgs["before"]; ok {
 2475		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2476		if err != nil {
 2477			return nil, err
 2478		}
 2479	}
 2480	args["before"] = arg1
 2481	var arg2 *int
 2482	if tmp, ok := rawArgs["first"]; ok {
 2483		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2484		if err != nil {
 2485			return nil, err
 2486		}
 2487	}
 2488	args["first"] = arg2
 2489	var arg3 *int
 2490	if tmp, ok := rawArgs["last"]; ok {
 2491		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2492		if err != nil {
 2493			return nil, err
 2494		}
 2495	}
 2496	args["last"] = arg3
 2497	return args, nil
 2498}
 2499
 2500func (ec *executionContext) field_Bug_operations_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2501	var err error
 2502	args := map[string]interface{}{}
 2503	var arg0 *string
 2504	if tmp, ok := rawArgs["after"]; ok {
 2505		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2506		if err != nil {
 2507			return nil, err
 2508		}
 2509	}
 2510	args["after"] = arg0
 2511	var arg1 *string
 2512	if tmp, ok := rawArgs["before"]; ok {
 2513		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2514		if err != nil {
 2515			return nil, err
 2516		}
 2517	}
 2518	args["before"] = arg1
 2519	var arg2 *int
 2520	if tmp, ok := rawArgs["first"]; ok {
 2521		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2522		if err != nil {
 2523			return nil, err
 2524		}
 2525	}
 2526	args["first"] = arg2
 2527	var arg3 *int
 2528	if tmp, ok := rawArgs["last"]; ok {
 2529		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2530		if err != nil {
 2531			return nil, err
 2532		}
 2533	}
 2534	args["last"] = arg3
 2535	return args, nil
 2536}
 2537
 2538func (ec *executionContext) field_Bug_participants_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2539	var err error
 2540	args := map[string]interface{}{}
 2541	var arg0 *string
 2542	if tmp, ok := rawArgs["after"]; ok {
 2543		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2544		if err != nil {
 2545			return nil, err
 2546		}
 2547	}
 2548	args["after"] = arg0
 2549	var arg1 *string
 2550	if tmp, ok := rawArgs["before"]; ok {
 2551		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2552		if err != nil {
 2553			return nil, err
 2554		}
 2555	}
 2556	args["before"] = arg1
 2557	var arg2 *int
 2558	if tmp, ok := rawArgs["first"]; ok {
 2559		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2560		if err != nil {
 2561			return nil, err
 2562		}
 2563	}
 2564	args["first"] = arg2
 2565	var arg3 *int
 2566	if tmp, ok := rawArgs["last"]; ok {
 2567		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2568		if err != nil {
 2569			return nil, err
 2570		}
 2571	}
 2572	args["last"] = arg3
 2573	return args, nil
 2574}
 2575
 2576func (ec *executionContext) field_Bug_timeline_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2577	var err error
 2578	args := map[string]interface{}{}
 2579	var arg0 *string
 2580	if tmp, ok := rawArgs["after"]; ok {
 2581		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2582		if err != nil {
 2583			return nil, err
 2584		}
 2585	}
 2586	args["after"] = arg0
 2587	var arg1 *string
 2588	if tmp, ok := rawArgs["before"]; ok {
 2589		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2590		if err != nil {
 2591			return nil, err
 2592		}
 2593	}
 2594	args["before"] = arg1
 2595	var arg2 *int
 2596	if tmp, ok := rawArgs["first"]; ok {
 2597		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2598		if err != nil {
 2599			return nil, err
 2600		}
 2601	}
 2602	args["first"] = arg2
 2603	var arg3 *int
 2604	if tmp, ok := rawArgs["last"]; ok {
 2605		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2606		if err != nil {
 2607			return nil, err
 2608		}
 2609	}
 2610	args["last"] = arg3
 2611	return args, nil
 2612}
 2613
 2614func (ec *executionContext) field_Mutation_addComment_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2615	var err error
 2616	args := map[string]interface{}{}
 2617	var arg0 models.AddCommentInput
 2618	if tmp, ok := rawArgs["input"]; ok {
 2619		arg0, err = ec.unmarshalNAddCommentInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentInput(ctx, tmp)
 2620		if err != nil {
 2621			return nil, err
 2622		}
 2623	}
 2624	args["input"] = arg0
 2625	return args, nil
 2626}
 2627
 2628func (ec *executionContext) field_Mutation_changeLabels_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2629	var err error
 2630	args := map[string]interface{}{}
 2631	var arg0 *models.ChangeLabelInput
 2632	if tmp, ok := rawArgs["input"]; ok {
 2633		arg0, err = ec.unmarshalOChangeLabelInput2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx, tmp)
 2634		if err != nil {
 2635			return nil, err
 2636		}
 2637	}
 2638	args["input"] = arg0
 2639	return args, nil
 2640}
 2641
 2642func (ec *executionContext) field_Mutation_closeBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2643	var err error
 2644	args := map[string]interface{}{}
 2645	var arg0 models.CloseBugInput
 2646	if tmp, ok := rawArgs["input"]; ok {
 2647		arg0, err = ec.unmarshalNCloseBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugInput(ctx, tmp)
 2648		if err != nil {
 2649			return nil, err
 2650		}
 2651	}
 2652	args["input"] = arg0
 2653	return args, nil
 2654}
 2655
 2656func (ec *executionContext) field_Mutation_commitAsNeeded_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2657	var err error
 2658	args := map[string]interface{}{}
 2659	var arg0 models.CommitAsNeededInput
 2660	if tmp, ok := rawArgs["input"]; ok {
 2661		arg0, err = ec.unmarshalNCommitAsNeededInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitAsNeededInput(ctx, tmp)
 2662		if err != nil {
 2663			return nil, err
 2664		}
 2665	}
 2666	args["input"] = arg0
 2667	return args, nil
 2668}
 2669
 2670func (ec *executionContext) field_Mutation_commit_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2671	var err error
 2672	args := map[string]interface{}{}
 2673	var arg0 models.CommitInput
 2674	if tmp, ok := rawArgs["input"]; ok {
 2675		arg0, err = ec.unmarshalNCommitInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitInput(ctx, tmp)
 2676		if err != nil {
 2677			return nil, err
 2678		}
 2679	}
 2680	args["input"] = arg0
 2681	return args, nil
 2682}
 2683
 2684func (ec *executionContext) field_Mutation_newBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2685	var err error
 2686	args := map[string]interface{}{}
 2687	var arg0 models.NewBugInput
 2688	if tmp, ok := rawArgs["input"]; ok {
 2689		arg0, err = ec.unmarshalNNewBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugInput(ctx, tmp)
 2690		if err != nil {
 2691			return nil, err
 2692		}
 2693	}
 2694	args["input"] = arg0
 2695	return args, nil
 2696}
 2697
 2698func (ec *executionContext) field_Mutation_openBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2699	var err error
 2700	args := map[string]interface{}{}
 2701	var arg0 models.OpenBugInput
 2702	if tmp, ok := rawArgs["input"]; ok {
 2703		arg0, err = ec.unmarshalNOpenBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugInput(ctx, tmp)
 2704		if err != nil {
 2705			return nil, err
 2706		}
 2707	}
 2708	args["input"] = arg0
 2709	return args, nil
 2710}
 2711
 2712func (ec *executionContext) field_Mutation_setTitle_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2713	var err error
 2714	args := map[string]interface{}{}
 2715	var arg0 models.SetTitleInput
 2716	if tmp, ok := rawArgs["input"]; ok {
 2717		arg0, err = ec.unmarshalNSetTitleInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitleInput(ctx, tmp)
 2718		if err != nil {
 2719			return nil, err
 2720		}
 2721	}
 2722	args["input"] = arg0
 2723	return args, nil
 2724}
 2725
 2726func (ec *executionContext) field_Query___type_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2727	var err error
 2728	args := map[string]interface{}{}
 2729	var arg0 string
 2730	if tmp, ok := rawArgs["name"]; ok {
 2731		arg0, err = ec.unmarshalNString2string(ctx, tmp)
 2732		if err != nil {
 2733			return nil, err
 2734		}
 2735	}
 2736	args["name"] = arg0
 2737	return args, nil
 2738}
 2739
 2740func (ec *executionContext) field_Query_repository_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2741	var err error
 2742	args := map[string]interface{}{}
 2743	var arg0 string
 2744	if tmp, ok := rawArgs["ref"]; ok {
 2745		arg0, err = ec.unmarshalNString2string(ctx, tmp)
 2746		if err != nil {
 2747			return nil, err
 2748		}
 2749	}
 2750	args["ref"] = arg0
 2751	return args, nil
 2752}
 2753
 2754func (ec *executionContext) field_Repository_allBugs_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2755	var err error
 2756	args := map[string]interface{}{}
 2757	var arg0 *string
 2758	if tmp, ok := rawArgs["after"]; ok {
 2759		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2760		if err != nil {
 2761			return nil, err
 2762		}
 2763	}
 2764	args["after"] = arg0
 2765	var arg1 *string
 2766	if tmp, ok := rawArgs["before"]; ok {
 2767		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2768		if err != nil {
 2769			return nil, err
 2770		}
 2771	}
 2772	args["before"] = arg1
 2773	var arg2 *int
 2774	if tmp, ok := rawArgs["first"]; ok {
 2775		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2776		if err != nil {
 2777			return nil, err
 2778		}
 2779	}
 2780	args["first"] = arg2
 2781	var arg3 *int
 2782	if tmp, ok := rawArgs["last"]; ok {
 2783		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2784		if err != nil {
 2785			return nil, err
 2786		}
 2787	}
 2788	args["last"] = arg3
 2789	var arg4 *string
 2790	if tmp, ok := rawArgs["query"]; ok {
 2791		arg4, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2792		if err != nil {
 2793			return nil, err
 2794		}
 2795	}
 2796	args["query"] = arg4
 2797	return args, nil
 2798}
 2799
 2800func (ec *executionContext) field_Repository_allIdentities_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2801	var err error
 2802	args := map[string]interface{}{}
 2803	var arg0 *string
 2804	if tmp, ok := rawArgs["after"]; ok {
 2805		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2806		if err != nil {
 2807			return nil, err
 2808		}
 2809	}
 2810	args["after"] = arg0
 2811	var arg1 *string
 2812	if tmp, ok := rawArgs["before"]; ok {
 2813		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2814		if err != nil {
 2815			return nil, err
 2816		}
 2817	}
 2818	args["before"] = arg1
 2819	var arg2 *int
 2820	if tmp, ok := rawArgs["first"]; ok {
 2821		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2822		if err != nil {
 2823			return nil, err
 2824		}
 2825	}
 2826	args["first"] = arg2
 2827	var arg3 *int
 2828	if tmp, ok := rawArgs["last"]; ok {
 2829		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2830		if err != nil {
 2831			return nil, err
 2832		}
 2833	}
 2834	args["last"] = arg3
 2835	return args, nil
 2836}
 2837
 2838func (ec *executionContext) field_Repository_bug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2839	var err error
 2840	args := map[string]interface{}{}
 2841	var arg0 string
 2842	if tmp, ok := rawArgs["prefix"]; ok {
 2843		arg0, err = ec.unmarshalNString2string(ctx, tmp)
 2844		if err != nil {
 2845			return nil, err
 2846		}
 2847	}
 2848	args["prefix"] = arg0
 2849	return args, nil
 2850}
 2851
 2852func (ec *executionContext) field_Repository_identity_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2853	var err error
 2854	args := map[string]interface{}{}
 2855	var arg0 string
 2856	if tmp, ok := rawArgs["prefix"]; ok {
 2857		arg0, err = ec.unmarshalNString2string(ctx, tmp)
 2858		if err != nil {
 2859			return nil, err
 2860		}
 2861	}
 2862	args["prefix"] = arg0
 2863	return args, nil
 2864}
 2865
 2866func (ec *executionContext) field___Type_enumValues_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2867	var err error
 2868	args := map[string]interface{}{}
 2869	var arg0 bool
 2870	if tmp, ok := rawArgs["includeDeprecated"]; ok {
 2871		arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
 2872		if err != nil {
 2873			return nil, err
 2874		}
 2875	}
 2876	args["includeDeprecated"] = arg0
 2877	return args, nil
 2878}
 2879
 2880func (ec *executionContext) field___Type_fields_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2881	var err error
 2882	args := map[string]interface{}{}
 2883	var arg0 bool
 2884	if tmp, ok := rawArgs["includeDeprecated"]; ok {
 2885		arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
 2886		if err != nil {
 2887			return nil, err
 2888		}
 2889	}
 2890	args["includeDeprecated"] = arg0
 2891	return args, nil
 2892}
 2893
 2894// endregion ***************************** args.gotpl *****************************
 2895
 2896// region    ************************** directives.gotpl **************************
 2897
 2898// endregion ************************** directives.gotpl **************************
 2899
 2900// region    **************************** field.gotpl *****************************
 2901
 2902func (ec *executionContext) _AddCommentOperation_hash(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
 2903	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 2904	defer func() {
 2905		if r := recover(); r != nil {
 2906			ec.Error(ctx, ec.Recover(ctx, r))
 2907			ret = graphql.Null
 2908		}
 2909		ec.Tracer.EndFieldExecution(ctx)
 2910	}()
 2911	rctx := &graphql.ResolverContext{
 2912		Object:   "AddCommentOperation",
 2913		Field:    field,
 2914		Args:     nil,
 2915		IsMethod: true,
 2916	}
 2917	ctx = graphql.WithResolverContext(ctx, rctx)
 2918	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 2919	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 2920		ctx = rctx // use context from middleware stack in children
 2921		return obj.Hash()
 2922	})
 2923	if err != nil {
 2924		ec.Error(ctx, err)
 2925		return graphql.Null
 2926	}
 2927	if resTmp == nil {
 2928		if !ec.HasError(rctx) {
 2929			ec.Errorf(ctx, "must not be null")
 2930		}
 2931		return graphql.Null
 2932	}
 2933	res := resTmp.(git.Hash)
 2934	rctx.Result = res
 2935	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 2936	return ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
 2937}
 2938
 2939func (ec *executionContext) _AddCommentOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
 2940	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 2941	defer func() {
 2942		if r := recover(); r != nil {
 2943			ec.Error(ctx, ec.Recover(ctx, r))
 2944			ret = graphql.Null
 2945		}
 2946		ec.Tracer.EndFieldExecution(ctx)
 2947	}()
 2948	rctx := &graphql.ResolverContext{
 2949		Object:   "AddCommentOperation",
 2950		Field:    field,
 2951		Args:     nil,
 2952		IsMethod: false,
 2953	}
 2954	ctx = graphql.WithResolverContext(ctx, rctx)
 2955	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 2956	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 2957		ctx = rctx // use context from middleware stack in children
 2958		return obj.Author, nil
 2959	})
 2960	if err != nil {
 2961		ec.Error(ctx, err)
 2962		return graphql.Null
 2963	}
 2964	if resTmp == nil {
 2965		if !ec.HasError(rctx) {
 2966			ec.Errorf(ctx, "must not be null")
 2967		}
 2968		return graphql.Null
 2969	}
 2970	res := resTmp.(identity.Interface)
 2971	rctx.Result = res
 2972	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 2973	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
 2974}
 2975
 2976func (ec *executionContext) _AddCommentOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
 2977	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 2978	defer func() {
 2979		if r := recover(); r != nil {
 2980			ec.Error(ctx, ec.Recover(ctx, r))
 2981			ret = graphql.Null
 2982		}
 2983		ec.Tracer.EndFieldExecution(ctx)
 2984	}()
 2985	rctx := &graphql.ResolverContext{
 2986		Object:   "AddCommentOperation",
 2987		Field:    field,
 2988		Args:     nil,
 2989		IsMethod: true,
 2990	}
 2991	ctx = graphql.WithResolverContext(ctx, rctx)
 2992	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 2993	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 2994		ctx = rctx // use context from middleware stack in children
 2995		return ec.resolvers.AddCommentOperation().Date(rctx, obj)
 2996	})
 2997	if err != nil {
 2998		ec.Error(ctx, err)
 2999		return graphql.Null
 3000	}
 3001	if resTmp == nil {
 3002		if !ec.HasError(rctx) {
 3003			ec.Errorf(ctx, "must not be null")
 3004		}
 3005		return graphql.Null
 3006	}
 3007	res := resTmp.(*time.Time)
 3008	rctx.Result = res
 3009	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3010	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 3011}
 3012
 3013func (ec *executionContext) _AddCommentOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
 3014	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3015	defer func() {
 3016		if r := recover(); r != nil {
 3017			ec.Error(ctx, ec.Recover(ctx, r))
 3018			ret = graphql.Null
 3019		}
 3020		ec.Tracer.EndFieldExecution(ctx)
 3021	}()
 3022	rctx := &graphql.ResolverContext{
 3023		Object:   "AddCommentOperation",
 3024		Field:    field,
 3025		Args:     nil,
 3026		IsMethod: false,
 3027	}
 3028	ctx = graphql.WithResolverContext(ctx, rctx)
 3029	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3030	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3031		ctx = rctx // use context from middleware stack in children
 3032		return obj.Message, nil
 3033	})
 3034	if err != nil {
 3035		ec.Error(ctx, err)
 3036		return graphql.Null
 3037	}
 3038	if resTmp == nil {
 3039		if !ec.HasError(rctx) {
 3040			ec.Errorf(ctx, "must not be null")
 3041		}
 3042		return graphql.Null
 3043	}
 3044	res := resTmp.(string)
 3045	rctx.Result = res
 3046	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3047	return ec.marshalNString2string(ctx, field.Selections, res)
 3048}
 3049
 3050func (ec *executionContext) _AddCommentOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) (ret graphql.Marshaler) {
 3051	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3052	defer func() {
 3053		if r := recover(); r != nil {
 3054			ec.Error(ctx, ec.Recover(ctx, r))
 3055			ret = graphql.Null
 3056		}
 3057		ec.Tracer.EndFieldExecution(ctx)
 3058	}()
 3059	rctx := &graphql.ResolverContext{
 3060		Object:   "AddCommentOperation",
 3061		Field:    field,
 3062		Args:     nil,
 3063		IsMethod: false,
 3064	}
 3065	ctx = graphql.WithResolverContext(ctx, rctx)
 3066	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3067	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3068		ctx = rctx // use context from middleware stack in children
 3069		return obj.Files, nil
 3070	})
 3071	if err != nil {
 3072		ec.Error(ctx, err)
 3073		return graphql.Null
 3074	}
 3075	if resTmp == nil {
 3076		if !ec.HasError(rctx) {
 3077			ec.Errorf(ctx, "must not be null")
 3078		}
 3079		return graphql.Null
 3080	}
 3081	res := resTmp.([]git.Hash)
 3082	rctx.Result = res
 3083	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3084	return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
 3085}
 3086
 3087func (ec *executionContext) _AddCommentPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) (ret graphql.Marshaler) {
 3088	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3089	defer func() {
 3090		if r := recover(); r != nil {
 3091			ec.Error(ctx, ec.Recover(ctx, r))
 3092			ret = graphql.Null
 3093		}
 3094		ec.Tracer.EndFieldExecution(ctx)
 3095	}()
 3096	rctx := &graphql.ResolverContext{
 3097		Object:   "AddCommentPayload",
 3098		Field:    field,
 3099		Args:     nil,
 3100		IsMethod: false,
 3101	}
 3102	ctx = graphql.WithResolverContext(ctx, rctx)
 3103	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3104	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3105		ctx = rctx // use context from middleware stack in children
 3106		return obj.ClientMutationID, nil
 3107	})
 3108	if err != nil {
 3109		ec.Error(ctx, err)
 3110		return graphql.Null
 3111	}
 3112	if resTmp == nil {
 3113		return graphql.Null
 3114	}
 3115	res := resTmp.(*string)
 3116	rctx.Result = res
 3117	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3118	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 3119}
 3120
 3121func (ec *executionContext) _AddCommentPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) (ret graphql.Marshaler) {
 3122	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3123	defer func() {
 3124		if r := recover(); r != nil {
 3125			ec.Error(ctx, ec.Recover(ctx, r))
 3126			ret = graphql.Null
 3127		}
 3128		ec.Tracer.EndFieldExecution(ctx)
 3129	}()
 3130	rctx := &graphql.ResolverContext{
 3131		Object:   "AddCommentPayload",
 3132		Field:    field,
 3133		Args:     nil,
 3134		IsMethod: false,
 3135	}
 3136	ctx = graphql.WithResolverContext(ctx, rctx)
 3137	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3138	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3139		ctx = rctx // use context from middleware stack in children
 3140		return obj.Bug, nil
 3141	})
 3142	if err != nil {
 3143		ec.Error(ctx, err)
 3144		return graphql.Null
 3145	}
 3146	if resTmp == nil {
 3147		if !ec.HasError(rctx) {
 3148			ec.Errorf(ctx, "must not be null")
 3149		}
 3150		return graphql.Null
 3151	}
 3152	res := resTmp.(*bug.Snapshot)
 3153	rctx.Result = res
 3154	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3155	return ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
 3156}
 3157
 3158func (ec *executionContext) _AddCommentPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) (ret graphql.Marshaler) {
 3159	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3160	defer func() {
 3161		if r := recover(); r != nil {
 3162			ec.Error(ctx, ec.Recover(ctx, r))
 3163			ret = graphql.Null
 3164		}
 3165		ec.Tracer.EndFieldExecution(ctx)
 3166	}()
 3167	rctx := &graphql.ResolverContext{
 3168		Object:   "AddCommentPayload",
 3169		Field:    field,
 3170		Args:     nil,
 3171		IsMethod: false,
 3172	}
 3173	ctx = graphql.WithResolverContext(ctx, rctx)
 3174	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3175	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3176		ctx = rctx // use context from middleware stack in children
 3177		return obj.Operation, nil
 3178	})
 3179	if err != nil {
 3180		ec.Error(ctx, err)
 3181		return graphql.Null
 3182	}
 3183	if resTmp == nil {
 3184		if !ec.HasError(rctx) {
 3185			ec.Errorf(ctx, "must not be null")
 3186		}
 3187		return graphql.Null
 3188	}
 3189	res := resTmp.(*bug.AddCommentOperation)
 3190	rctx.Result = res
 3191	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3192	return ec.marshalNAddCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx, field.Selections, res)
 3193}
 3194
 3195func (ec *executionContext) _AddCommentTimelineItem_hash(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3196	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3197	defer func() {
 3198		if r := recover(); r != nil {
 3199			ec.Error(ctx, ec.Recover(ctx, r))
 3200			ret = graphql.Null
 3201		}
 3202		ec.Tracer.EndFieldExecution(ctx)
 3203	}()
 3204	rctx := &graphql.ResolverContext{
 3205		Object:   "AddCommentTimelineItem",
 3206		Field:    field,
 3207		Args:     nil,
 3208		IsMethod: true,
 3209	}
 3210	ctx = graphql.WithResolverContext(ctx, rctx)
 3211	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3212	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3213		ctx = rctx // use context from middleware stack in children
 3214		return obj.Hash(), nil
 3215	})
 3216	if err != nil {
 3217		ec.Error(ctx, err)
 3218		return graphql.Null
 3219	}
 3220	if resTmp == nil {
 3221		if !ec.HasError(rctx) {
 3222			ec.Errorf(ctx, "must not be null")
 3223		}
 3224		return graphql.Null
 3225	}
 3226	res := resTmp.(git.Hash)
 3227	rctx.Result = res
 3228	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3229	return ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
 3230}
 3231
 3232func (ec *executionContext) _AddCommentTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3233	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3234	defer func() {
 3235		if r := recover(); r != nil {
 3236			ec.Error(ctx, ec.Recover(ctx, r))
 3237			ret = graphql.Null
 3238		}
 3239		ec.Tracer.EndFieldExecution(ctx)
 3240	}()
 3241	rctx := &graphql.ResolverContext{
 3242		Object:   "AddCommentTimelineItem",
 3243		Field:    field,
 3244		Args:     nil,
 3245		IsMethod: false,
 3246	}
 3247	ctx = graphql.WithResolverContext(ctx, rctx)
 3248	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3249	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3250		ctx = rctx // use context from middleware stack in children
 3251		return obj.Author, nil
 3252	})
 3253	if err != nil {
 3254		ec.Error(ctx, err)
 3255		return graphql.Null
 3256	}
 3257	if resTmp == nil {
 3258		if !ec.HasError(rctx) {
 3259			ec.Errorf(ctx, "must not be null")
 3260		}
 3261		return graphql.Null
 3262	}
 3263	res := resTmp.(identity.Interface)
 3264	rctx.Result = res
 3265	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3266	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
 3267}
 3268
 3269func (ec *executionContext) _AddCommentTimelineItem_message(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3270	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3271	defer func() {
 3272		if r := recover(); r != nil {
 3273			ec.Error(ctx, ec.Recover(ctx, r))
 3274			ret = graphql.Null
 3275		}
 3276		ec.Tracer.EndFieldExecution(ctx)
 3277	}()
 3278	rctx := &graphql.ResolverContext{
 3279		Object:   "AddCommentTimelineItem",
 3280		Field:    field,
 3281		Args:     nil,
 3282		IsMethod: false,
 3283	}
 3284	ctx = graphql.WithResolverContext(ctx, rctx)
 3285	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3286	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3287		ctx = rctx // use context from middleware stack in children
 3288		return obj.Message, nil
 3289	})
 3290	if err != nil {
 3291		ec.Error(ctx, err)
 3292		return graphql.Null
 3293	}
 3294	if resTmp == nil {
 3295		if !ec.HasError(rctx) {
 3296			ec.Errorf(ctx, "must not be null")
 3297		}
 3298		return graphql.Null
 3299	}
 3300	res := resTmp.(string)
 3301	rctx.Result = res
 3302	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3303	return ec.marshalNString2string(ctx, field.Selections, res)
 3304}
 3305
 3306func (ec *executionContext) _AddCommentTimelineItem_messageIsEmpty(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3307	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3308	defer func() {
 3309		if r := recover(); r != nil {
 3310			ec.Error(ctx, ec.Recover(ctx, r))
 3311			ret = graphql.Null
 3312		}
 3313		ec.Tracer.EndFieldExecution(ctx)
 3314	}()
 3315	rctx := &graphql.ResolverContext{
 3316		Object:   "AddCommentTimelineItem",
 3317		Field:    field,
 3318		Args:     nil,
 3319		IsMethod: true,
 3320	}
 3321	ctx = graphql.WithResolverContext(ctx, rctx)
 3322	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3323	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3324		ctx = rctx // use context from middleware stack in children
 3325		return obj.MessageIsEmpty(), nil
 3326	})
 3327	if err != nil {
 3328		ec.Error(ctx, err)
 3329		return graphql.Null
 3330	}
 3331	if resTmp == nil {
 3332		if !ec.HasError(rctx) {
 3333			ec.Errorf(ctx, "must not be null")
 3334		}
 3335		return graphql.Null
 3336	}
 3337	res := resTmp.(bool)
 3338	rctx.Result = res
 3339	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3340	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 3341}
 3342
 3343func (ec *executionContext) _AddCommentTimelineItem_files(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3344	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3345	defer func() {
 3346		if r := recover(); r != nil {
 3347			ec.Error(ctx, ec.Recover(ctx, r))
 3348			ret = graphql.Null
 3349		}
 3350		ec.Tracer.EndFieldExecution(ctx)
 3351	}()
 3352	rctx := &graphql.ResolverContext{
 3353		Object:   "AddCommentTimelineItem",
 3354		Field:    field,
 3355		Args:     nil,
 3356		IsMethod: false,
 3357	}
 3358	ctx = graphql.WithResolverContext(ctx, rctx)
 3359	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3360	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3361		ctx = rctx // use context from middleware stack in children
 3362		return obj.Files, nil
 3363	})
 3364	if err != nil {
 3365		ec.Error(ctx, err)
 3366		return graphql.Null
 3367	}
 3368	if resTmp == nil {
 3369		if !ec.HasError(rctx) {
 3370			ec.Errorf(ctx, "must not be null")
 3371		}
 3372		return graphql.Null
 3373	}
 3374	res := resTmp.([]git.Hash)
 3375	rctx.Result = res
 3376	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3377	return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
 3378}
 3379
 3380func (ec *executionContext) _AddCommentTimelineItem_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3381	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3382	defer func() {
 3383		if r := recover(); r != nil {
 3384			ec.Error(ctx, ec.Recover(ctx, r))
 3385			ret = graphql.Null
 3386		}
 3387		ec.Tracer.EndFieldExecution(ctx)
 3388	}()
 3389	rctx := &graphql.ResolverContext{
 3390		Object:   "AddCommentTimelineItem",
 3391		Field:    field,
 3392		Args:     nil,
 3393		IsMethod: true,
 3394	}
 3395	ctx = graphql.WithResolverContext(ctx, rctx)
 3396	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3397	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3398		ctx = rctx // use context from middleware stack in children
 3399		return ec.resolvers.AddCommentTimelineItem().CreatedAt(rctx, obj)
 3400	})
 3401	if err != nil {
 3402		ec.Error(ctx, err)
 3403		return graphql.Null
 3404	}
 3405	if resTmp == nil {
 3406		if !ec.HasError(rctx) {
 3407			ec.Errorf(ctx, "must not be null")
 3408		}
 3409		return graphql.Null
 3410	}
 3411	res := resTmp.(*time.Time)
 3412	rctx.Result = res
 3413	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3414	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 3415}
 3416
 3417func (ec *executionContext) _AddCommentTimelineItem_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3418	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3419	defer func() {
 3420		if r := recover(); r != nil {
 3421			ec.Error(ctx, ec.Recover(ctx, r))
 3422			ret = graphql.Null
 3423		}
 3424		ec.Tracer.EndFieldExecution(ctx)
 3425	}()
 3426	rctx := &graphql.ResolverContext{
 3427		Object:   "AddCommentTimelineItem",
 3428		Field:    field,
 3429		Args:     nil,
 3430		IsMethod: true,
 3431	}
 3432	ctx = graphql.WithResolverContext(ctx, rctx)
 3433	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3434	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3435		ctx = rctx // use context from middleware stack in children
 3436		return ec.resolvers.AddCommentTimelineItem().LastEdit(rctx, obj)
 3437	})
 3438	if err != nil {
 3439		ec.Error(ctx, err)
 3440		return graphql.Null
 3441	}
 3442	if resTmp == nil {
 3443		if !ec.HasError(rctx) {
 3444			ec.Errorf(ctx, "must not be null")
 3445		}
 3446		return graphql.Null
 3447	}
 3448	res := resTmp.(*time.Time)
 3449	rctx.Result = res
 3450	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3451	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 3452}
 3453
 3454func (ec *executionContext) _AddCommentTimelineItem_edited(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3455	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3456	defer func() {
 3457		if r := recover(); r != nil {
 3458			ec.Error(ctx, ec.Recover(ctx, r))
 3459			ret = graphql.Null
 3460		}
 3461		ec.Tracer.EndFieldExecution(ctx)
 3462	}()
 3463	rctx := &graphql.ResolverContext{
 3464		Object:   "AddCommentTimelineItem",
 3465		Field:    field,
 3466		Args:     nil,
 3467		IsMethod: true,
 3468	}
 3469	ctx = graphql.WithResolverContext(ctx, rctx)
 3470	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3471	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3472		ctx = rctx // use context from middleware stack in children
 3473		return obj.Edited(), nil
 3474	})
 3475	if err != nil {
 3476		ec.Error(ctx, err)
 3477		return graphql.Null
 3478	}
 3479	if resTmp == nil {
 3480		if !ec.HasError(rctx) {
 3481			ec.Errorf(ctx, "must not be null")
 3482		}
 3483		return graphql.Null
 3484	}
 3485	res := resTmp.(bool)
 3486	rctx.Result = res
 3487	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3488	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 3489}
 3490
 3491func (ec *executionContext) _AddCommentTimelineItem_history(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) (ret graphql.Marshaler) {
 3492	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3493	defer func() {
 3494		if r := recover(); r != nil {
 3495			ec.Error(ctx, ec.Recover(ctx, r))
 3496			ret = graphql.Null
 3497		}
 3498		ec.Tracer.EndFieldExecution(ctx)
 3499	}()
 3500	rctx := &graphql.ResolverContext{
 3501		Object:   "AddCommentTimelineItem",
 3502		Field:    field,
 3503		Args:     nil,
 3504		IsMethod: false,
 3505	}
 3506	ctx = graphql.WithResolverContext(ctx, rctx)
 3507	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3508	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3509		ctx = rctx // use context from middleware stack in children
 3510		return obj.History, nil
 3511	})
 3512	if err != nil {
 3513		ec.Error(ctx, err)
 3514		return graphql.Null
 3515	}
 3516	if resTmp == nil {
 3517		if !ec.HasError(rctx) {
 3518			ec.Errorf(ctx, "must not be null")
 3519		}
 3520		return graphql.Null
 3521	}
 3522	res := resTmp.([]bug.CommentHistoryStep)
 3523	rctx.Result = res
 3524	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3525	return ec.marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx, field.Selections, res)
 3526}
 3527
 3528func (ec *executionContext) _Bug_id(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
 3529	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3530	defer func() {
 3531		if r := recover(); r != nil {
 3532			ec.Error(ctx, ec.Recover(ctx, r))
 3533			ret = graphql.Null
 3534		}
 3535		ec.Tracer.EndFieldExecution(ctx)
 3536	}()
 3537	rctx := &graphql.ResolverContext{
 3538		Object:   "Bug",
 3539		Field:    field,
 3540		Args:     nil,
 3541		IsMethod: true,
 3542	}
 3543	ctx = graphql.WithResolverContext(ctx, rctx)
 3544	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3545	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3546		ctx = rctx // use context from middleware stack in children
 3547		return obj.Id(), nil
 3548	})
 3549	if err != nil {
 3550		ec.Error(ctx, err)
 3551		return graphql.Null
 3552	}
 3553	if resTmp == nil {
 3554		if !ec.HasError(rctx) {
 3555			ec.Errorf(ctx, "must not be null")
 3556		}
 3557		return graphql.Null
 3558	}
 3559	res := resTmp.(string)
 3560	rctx.Result = res
 3561	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3562	return ec.marshalNString2string(ctx, field.Selections, res)
 3563}
 3564
 3565func (ec *executionContext) _Bug_humanId(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
 3566	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3567	defer func() {
 3568		if r := recover(); r != nil {
 3569			ec.Error(ctx, ec.Recover(ctx, r))
 3570			ret = graphql.Null
 3571		}
 3572		ec.Tracer.EndFieldExecution(ctx)
 3573	}()
 3574	rctx := &graphql.ResolverContext{
 3575		Object:   "Bug",
 3576		Field:    field,
 3577		Args:     nil,
 3578		IsMethod: true,
 3579	}
 3580	ctx = graphql.WithResolverContext(ctx, rctx)
 3581	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3582	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3583		ctx = rctx // use context from middleware stack in children
 3584		return obj.HumanId(), nil
 3585	})
 3586	if err != nil {
 3587		ec.Error(ctx, err)
 3588		return graphql.Null
 3589	}
 3590	if resTmp == nil {
 3591		if !ec.HasError(rctx) {
 3592			ec.Errorf(ctx, "must not be null")
 3593		}
 3594		return graphql.Null
 3595	}
 3596	res := resTmp.(string)
 3597	rctx.Result = res
 3598	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3599	return ec.marshalNString2string(ctx, field.Selections, res)
 3600}
 3601
 3602func (ec *executionContext) _Bug_status(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
 3603	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3604	defer func() {
 3605		if r := recover(); r != nil {
 3606			ec.Error(ctx, ec.Recover(ctx, r))
 3607			ret = graphql.Null
 3608		}
 3609		ec.Tracer.EndFieldExecution(ctx)
 3610	}()
 3611	rctx := &graphql.ResolverContext{
 3612		Object:   "Bug",
 3613		Field:    field,
 3614		Args:     nil,
 3615		IsMethod: true,
 3616	}
 3617	ctx = graphql.WithResolverContext(ctx, rctx)
 3618	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3619	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3620		ctx = rctx // use context from middleware stack in children
 3621		return ec.resolvers.Bug().Status(rctx, obj)
 3622	})
 3623	if err != nil {
 3624		ec.Error(ctx, err)
 3625		return graphql.Null
 3626	}
 3627	if resTmp == nil {
 3628		if !ec.HasError(rctx) {
 3629			ec.Errorf(ctx, "must not be null")
 3630		}
 3631		return graphql.Null
 3632	}
 3633	res := resTmp.(models.Status)
 3634	rctx.Result = res
 3635	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3636	return ec.marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx, field.Selections, res)
 3637}
 3638
 3639func (ec *executionContext) _Bug_title(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
 3640	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3641	defer func() {
 3642		if r := recover(); r != nil {
 3643			ec.Error(ctx, ec.Recover(ctx, r))
 3644			ret = graphql.Null
 3645		}
 3646		ec.Tracer.EndFieldExecution(ctx)
 3647	}()
 3648	rctx := &graphql.ResolverContext{
 3649		Object:   "Bug",
 3650		Field:    field,
 3651		Args:     nil,
 3652		IsMethod: false,
 3653	}
 3654	ctx = graphql.WithResolverContext(ctx, rctx)
 3655	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3656	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3657		ctx = rctx // use context from middleware stack in children
 3658		return obj.Title, nil
 3659	})
 3660	if err != nil {
 3661		ec.Error(ctx, err)
 3662		return graphql.Null
 3663	}
 3664	if resTmp == nil {
 3665		if !ec.HasError(rctx) {
 3666			ec.Errorf(ctx, "must not be null")
 3667		}
 3668		return graphql.Null
 3669	}
 3670	res := resTmp.(string)
 3671	rctx.Result = res
 3672	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3673	return ec.marshalNString2string(ctx, field.Selections, res)
 3674}
 3675
 3676func (ec *executionContext) _Bug_labels(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
 3677	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3678	defer func() {
 3679		if r := recover(); r != nil {
 3680			ec.Error(ctx, ec.Recover(ctx, r))
 3681			ret = graphql.Null
 3682		}
 3683		ec.Tracer.EndFieldExecution(ctx)
 3684	}()
 3685	rctx := &graphql.ResolverContext{
 3686		Object:   "Bug",
 3687		Field:    field,
 3688		Args:     nil,
 3689		IsMethod: false,
 3690	}
 3691	ctx = graphql.WithResolverContext(ctx, rctx)
 3692	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3693	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3694		ctx = rctx // use context from middleware stack in children
 3695		return obj.Labels, nil
 3696	})
 3697	if err != nil {
 3698		ec.Error(ctx, err)
 3699		return graphql.Null
 3700	}
 3701	if resTmp == nil {
 3702		if !ec.HasError(rctx) {
 3703			ec.Errorf(ctx, "must not be null")
 3704		}
 3705		return graphql.Null
 3706	}
 3707	res := resTmp.([]bug.Label)
 3708	rctx.Result = res
 3709	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3710	return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
 3711}
 3712
 3713func (ec *executionContext) _Bug_author(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
 3714	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3715	defer func() {
 3716		if r := recover(); r != nil {
 3717			ec.Error(ctx, ec.Recover(ctx, r))
 3718			ret = graphql.Null
 3719		}
 3720		ec.Tracer.EndFieldExecution(ctx)
 3721	}()
 3722	rctx := &graphql.ResolverContext{
 3723		Object:   "Bug",
 3724		Field:    field,
 3725		Args:     nil,
 3726		IsMethod: false,
 3727	}
 3728	ctx = graphql.WithResolverContext(ctx, rctx)
 3729	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3730	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3731		ctx = rctx // use context from middleware stack in children
 3732		return obj.Author, nil
 3733	})
 3734	if err != nil {
 3735		ec.Error(ctx, err)
 3736		return graphql.Null
 3737	}
 3738	if resTmp == nil {
 3739		if !ec.HasError(rctx) {
 3740			ec.Errorf(ctx, "must not be null")
 3741		}
 3742		return graphql.Null
 3743	}
 3744	res := resTmp.(identity.Interface)
 3745	rctx.Result = res
 3746	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3747	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
 3748}
 3749
 3750func (ec *executionContext) _Bug_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
 3751	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3752	defer func() {
 3753		if r := recover(); r != nil {
 3754			ec.Error(ctx, ec.Recover(ctx, r))
 3755			ret = graphql.Null
 3756		}
 3757		ec.Tracer.EndFieldExecution(ctx)
 3758	}()
 3759	rctx := &graphql.ResolverContext{
 3760		Object:   "Bug",
 3761		Field:    field,
 3762		Args:     nil,
 3763		IsMethod: false,
 3764	}
 3765	ctx = graphql.WithResolverContext(ctx, rctx)
 3766	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3767	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3768		ctx = rctx // use context from middleware stack in children
 3769		return obj.CreatedAt, nil
 3770	})
 3771	if err != nil {
 3772		ec.Error(ctx, err)
 3773		return graphql.Null
 3774	}
 3775	if resTmp == nil {
 3776		if !ec.HasError(rctx) {
 3777			ec.Errorf(ctx, "must not be null")
 3778		}
 3779		return graphql.Null
 3780	}
 3781	res := resTmp.(time.Time)
 3782	rctx.Result = res
 3783	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3784	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
 3785}
 3786
 3787func (ec *executionContext) _Bug_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
 3788	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3789	defer func() {
 3790		if r := recover(); r != nil {
 3791			ec.Error(ctx, ec.Recover(ctx, r))
 3792			ret = graphql.Null
 3793		}
 3794		ec.Tracer.EndFieldExecution(ctx)
 3795	}()
 3796	rctx := &graphql.ResolverContext{
 3797		Object:   "Bug",
 3798		Field:    field,
 3799		Args:     nil,
 3800		IsMethod: true,
 3801	}
 3802	ctx = graphql.WithResolverContext(ctx, rctx)
 3803	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3804	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3805		ctx = rctx // use context from middleware stack in children
 3806		return ec.resolvers.Bug().LastEdit(rctx, obj)
 3807	})
 3808	if err != nil {
 3809		ec.Error(ctx, err)
 3810		return graphql.Null
 3811	}
 3812	if resTmp == nil {
 3813		if !ec.HasError(rctx) {
 3814			ec.Errorf(ctx, "must not be null")
 3815		}
 3816		return graphql.Null
 3817	}
 3818	res := resTmp.(*time.Time)
 3819	rctx.Result = res
 3820	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3821	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 3822}
 3823
 3824func (ec *executionContext) _Bug_actors(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
 3825	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3826	defer func() {
 3827		if r := recover(); r != nil {
 3828			ec.Error(ctx, ec.Recover(ctx, r))
 3829			ret = graphql.Null
 3830		}
 3831		ec.Tracer.EndFieldExecution(ctx)
 3832	}()
 3833	rctx := &graphql.ResolverContext{
 3834		Object:   "Bug",
 3835		Field:    field,
 3836		Args:     nil,
 3837		IsMethod: true,
 3838	}
 3839	ctx = graphql.WithResolverContext(ctx, rctx)
 3840	rawArgs := field.ArgumentMap(ec.Variables)
 3841	args, err := ec.field_Bug_actors_args(ctx, rawArgs)
 3842	if err != nil {
 3843		ec.Error(ctx, err)
 3844		return graphql.Null
 3845	}
 3846	rctx.Args = args
 3847	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3848	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3849		ctx = rctx // use context from middleware stack in children
 3850		return ec.resolvers.Bug().Actors(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
 3851	})
 3852	if err != nil {
 3853		ec.Error(ctx, err)
 3854		return graphql.Null
 3855	}
 3856	if resTmp == nil {
 3857		if !ec.HasError(rctx) {
 3858			ec.Errorf(ctx, "must not be null")
 3859		}
 3860		return graphql.Null
 3861	}
 3862	res := resTmp.(*models.IdentityConnection)
 3863	rctx.Result = res
 3864	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3865	return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
 3866}
 3867
 3868func (ec *executionContext) _Bug_participants(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
 3869	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3870	defer func() {
 3871		if r := recover(); r != nil {
 3872			ec.Error(ctx, ec.Recover(ctx, r))
 3873			ret = graphql.Null
 3874		}
 3875		ec.Tracer.EndFieldExecution(ctx)
 3876	}()
 3877	rctx := &graphql.ResolverContext{
 3878		Object:   "Bug",
 3879		Field:    field,
 3880		Args:     nil,
 3881		IsMethod: true,
 3882	}
 3883	ctx = graphql.WithResolverContext(ctx, rctx)
 3884	rawArgs := field.ArgumentMap(ec.Variables)
 3885	args, err := ec.field_Bug_participants_args(ctx, rawArgs)
 3886	if err != nil {
 3887		ec.Error(ctx, err)
 3888		return graphql.Null
 3889	}
 3890	rctx.Args = args
 3891	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3892	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3893		ctx = rctx // use context from middleware stack in children
 3894		return ec.resolvers.Bug().Participants(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
 3895	})
 3896	if err != nil {
 3897		ec.Error(ctx, err)
 3898		return graphql.Null
 3899	}
 3900	if resTmp == nil {
 3901		if !ec.HasError(rctx) {
 3902			ec.Errorf(ctx, "must not be null")
 3903		}
 3904		return graphql.Null
 3905	}
 3906	res := resTmp.(*models.IdentityConnection)
 3907	rctx.Result = res
 3908	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3909	return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
 3910}
 3911
 3912func (ec *executionContext) _Bug_comments(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
 3913	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3914	defer func() {
 3915		if r := recover(); r != nil {
 3916			ec.Error(ctx, ec.Recover(ctx, r))
 3917			ret = graphql.Null
 3918		}
 3919		ec.Tracer.EndFieldExecution(ctx)
 3920	}()
 3921	rctx := &graphql.ResolverContext{
 3922		Object:   "Bug",
 3923		Field:    field,
 3924		Args:     nil,
 3925		IsMethod: true,
 3926	}
 3927	ctx = graphql.WithResolverContext(ctx, rctx)
 3928	rawArgs := field.ArgumentMap(ec.Variables)
 3929	args, err := ec.field_Bug_comments_args(ctx, rawArgs)
 3930	if err != nil {
 3931		ec.Error(ctx, err)
 3932		return graphql.Null
 3933	}
 3934	rctx.Args = args
 3935	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3936	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3937		ctx = rctx // use context from middleware stack in children
 3938		return ec.resolvers.Bug().Comments(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
 3939	})
 3940	if err != nil {
 3941		ec.Error(ctx, err)
 3942		return graphql.Null
 3943	}
 3944	if resTmp == nil {
 3945		if !ec.HasError(rctx) {
 3946			ec.Errorf(ctx, "must not be null")
 3947		}
 3948		return graphql.Null
 3949	}
 3950	res := resTmp.(*models.CommentConnection)
 3951	rctx.Result = res
 3952	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3953	return ec.marshalNCommentConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentConnection(ctx, field.Selections, res)
 3954}
 3955
 3956func (ec *executionContext) _Bug_timeline(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
 3957	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3958	defer func() {
 3959		if r := recover(); r != nil {
 3960			ec.Error(ctx, ec.Recover(ctx, r))
 3961			ret = graphql.Null
 3962		}
 3963		ec.Tracer.EndFieldExecution(ctx)
 3964	}()
 3965	rctx := &graphql.ResolverContext{
 3966		Object:   "Bug",
 3967		Field:    field,
 3968		Args:     nil,
 3969		IsMethod: true,
 3970	}
 3971	ctx = graphql.WithResolverContext(ctx, rctx)
 3972	rawArgs := field.ArgumentMap(ec.Variables)
 3973	args, err := ec.field_Bug_timeline_args(ctx, rawArgs)
 3974	if err != nil {
 3975		ec.Error(ctx, err)
 3976		return graphql.Null
 3977	}
 3978	rctx.Args = args
 3979	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3980	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 3981		ctx = rctx // use context from middleware stack in children
 3982		return ec.resolvers.Bug().Timeline(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
 3983	})
 3984	if err != nil {
 3985		ec.Error(ctx, err)
 3986		return graphql.Null
 3987	}
 3988	if resTmp == nil {
 3989		if !ec.HasError(rctx) {
 3990			ec.Errorf(ctx, "must not be null")
 3991		}
 3992		return graphql.Null
 3993	}
 3994	res := resTmp.(*models.TimelineItemConnection)
 3995	rctx.Result = res
 3996	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3997	return ec.marshalNTimelineItemConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx, field.Selections, res)
 3998}
 3999
 4000func (ec *executionContext) _Bug_operations(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) (ret graphql.Marshaler) {
 4001	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4002	defer func() {
 4003		if r := recover(); r != nil {
 4004			ec.Error(ctx, ec.Recover(ctx, r))
 4005			ret = graphql.Null
 4006		}
 4007		ec.Tracer.EndFieldExecution(ctx)
 4008	}()
 4009	rctx := &graphql.ResolverContext{
 4010		Object:   "Bug",
 4011		Field:    field,
 4012		Args:     nil,
 4013		IsMethod: true,
 4014	}
 4015	ctx = graphql.WithResolverContext(ctx, rctx)
 4016	rawArgs := field.ArgumentMap(ec.Variables)
 4017	args, err := ec.field_Bug_operations_args(ctx, rawArgs)
 4018	if err != nil {
 4019		ec.Error(ctx, err)
 4020		return graphql.Null
 4021	}
 4022	rctx.Args = args
 4023	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4024	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4025		ctx = rctx // use context from middleware stack in children
 4026		return ec.resolvers.Bug().Operations(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
 4027	})
 4028	if err != nil {
 4029		ec.Error(ctx, err)
 4030		return graphql.Null
 4031	}
 4032	if resTmp == nil {
 4033		if !ec.HasError(rctx) {
 4034			ec.Errorf(ctx, "must not be null")
 4035		}
 4036		return graphql.Null
 4037	}
 4038	res := resTmp.(*models.OperationConnection)
 4039	rctx.Result = res
 4040	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4041	return ec.marshalNOperationConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationConnection(ctx, field.Selections, res)
 4042}
 4043
 4044func (ec *executionContext) _BugConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
 4045	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4046	defer func() {
 4047		if r := recover(); r != nil {
 4048			ec.Error(ctx, ec.Recover(ctx, r))
 4049			ret = graphql.Null
 4050		}
 4051		ec.Tracer.EndFieldExecution(ctx)
 4052	}()
 4053	rctx := &graphql.ResolverContext{
 4054		Object:   "BugConnection",
 4055		Field:    field,
 4056		Args:     nil,
 4057		IsMethod: false,
 4058	}
 4059	ctx = graphql.WithResolverContext(ctx, rctx)
 4060	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4061	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4062		ctx = rctx // use context from middleware stack in children
 4063		return obj.Edges, nil
 4064	})
 4065	if err != nil {
 4066		ec.Error(ctx, err)
 4067		return graphql.Null
 4068	}
 4069	if resTmp == nil {
 4070		if !ec.HasError(rctx) {
 4071			ec.Errorf(ctx, "must not be null")
 4072		}
 4073		return graphql.Null
 4074	}
 4075	res := resTmp.([]*models.BugEdge)
 4076	rctx.Result = res
 4077	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4078	return ec.marshalNBugEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx, field.Selections, res)
 4079}
 4080
 4081func (ec *executionContext) _BugConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
 4082	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4083	defer func() {
 4084		if r := recover(); r != nil {
 4085			ec.Error(ctx, ec.Recover(ctx, r))
 4086			ret = graphql.Null
 4087		}
 4088		ec.Tracer.EndFieldExecution(ctx)
 4089	}()
 4090	rctx := &graphql.ResolverContext{
 4091		Object:   "BugConnection",
 4092		Field:    field,
 4093		Args:     nil,
 4094		IsMethod: false,
 4095	}
 4096	ctx = graphql.WithResolverContext(ctx, rctx)
 4097	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4098	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4099		ctx = rctx // use context from middleware stack in children
 4100		return obj.Nodes, nil
 4101	})
 4102	if err != nil {
 4103		ec.Error(ctx, err)
 4104		return graphql.Null
 4105	}
 4106	if resTmp == nil {
 4107		if !ec.HasError(rctx) {
 4108			ec.Errorf(ctx, "must not be null")
 4109		}
 4110		return graphql.Null
 4111	}
 4112	res := resTmp.([]*bug.Snapshot)
 4113	rctx.Result = res
 4114	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4115	return ec.marshalNBug2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
 4116}
 4117
 4118func (ec *executionContext) _BugConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
 4119	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4120	defer func() {
 4121		if r := recover(); r != nil {
 4122			ec.Error(ctx, ec.Recover(ctx, r))
 4123			ret = graphql.Null
 4124		}
 4125		ec.Tracer.EndFieldExecution(ctx)
 4126	}()
 4127	rctx := &graphql.ResolverContext{
 4128		Object:   "BugConnection",
 4129		Field:    field,
 4130		Args:     nil,
 4131		IsMethod: false,
 4132	}
 4133	ctx = graphql.WithResolverContext(ctx, rctx)
 4134	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4135	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4136		ctx = rctx // use context from middleware stack in children
 4137		return obj.PageInfo, nil
 4138	})
 4139	if err != nil {
 4140		ec.Error(ctx, err)
 4141		return graphql.Null
 4142	}
 4143	if resTmp == nil {
 4144		if !ec.HasError(rctx) {
 4145			ec.Errorf(ctx, "must not be null")
 4146		}
 4147		return graphql.Null
 4148	}
 4149	res := resTmp.(*models.PageInfo)
 4150	rctx.Result = res
 4151	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4152	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
 4153}
 4154
 4155func (ec *executionContext) _BugConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) (ret graphql.Marshaler) {
 4156	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4157	defer func() {
 4158		if r := recover(); r != nil {
 4159			ec.Error(ctx, ec.Recover(ctx, r))
 4160			ret = graphql.Null
 4161		}
 4162		ec.Tracer.EndFieldExecution(ctx)
 4163	}()
 4164	rctx := &graphql.ResolverContext{
 4165		Object:   "BugConnection",
 4166		Field:    field,
 4167		Args:     nil,
 4168		IsMethod: false,
 4169	}
 4170	ctx = graphql.WithResolverContext(ctx, rctx)
 4171	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4172	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4173		ctx = rctx // use context from middleware stack in children
 4174		return obj.TotalCount, nil
 4175	})
 4176	if err != nil {
 4177		ec.Error(ctx, err)
 4178		return graphql.Null
 4179	}
 4180	if resTmp == nil {
 4181		if !ec.HasError(rctx) {
 4182			ec.Errorf(ctx, "must not be null")
 4183		}
 4184		return graphql.Null
 4185	}
 4186	res := resTmp.(int)
 4187	rctx.Result = res
 4188	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4189	return ec.marshalNInt2int(ctx, field.Selections, res)
 4190}
 4191
 4192func (ec *executionContext) _BugEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.BugEdge) (ret graphql.Marshaler) {
 4193	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4194	defer func() {
 4195		if r := recover(); r != nil {
 4196			ec.Error(ctx, ec.Recover(ctx, r))
 4197			ret = graphql.Null
 4198		}
 4199		ec.Tracer.EndFieldExecution(ctx)
 4200	}()
 4201	rctx := &graphql.ResolverContext{
 4202		Object:   "BugEdge",
 4203		Field:    field,
 4204		Args:     nil,
 4205		IsMethod: false,
 4206	}
 4207	ctx = graphql.WithResolverContext(ctx, rctx)
 4208	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4209	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4210		ctx = rctx // use context from middleware stack in children
 4211		return obj.Cursor, nil
 4212	})
 4213	if err != nil {
 4214		ec.Error(ctx, err)
 4215		return graphql.Null
 4216	}
 4217	if resTmp == nil {
 4218		if !ec.HasError(rctx) {
 4219			ec.Errorf(ctx, "must not be null")
 4220		}
 4221		return graphql.Null
 4222	}
 4223	res := resTmp.(string)
 4224	rctx.Result = res
 4225	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4226	return ec.marshalNString2string(ctx, field.Selections, res)
 4227}
 4228
 4229func (ec *executionContext) _BugEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.BugEdge) (ret graphql.Marshaler) {
 4230	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4231	defer func() {
 4232		if r := recover(); r != nil {
 4233			ec.Error(ctx, ec.Recover(ctx, r))
 4234			ret = graphql.Null
 4235		}
 4236		ec.Tracer.EndFieldExecution(ctx)
 4237	}()
 4238	rctx := &graphql.ResolverContext{
 4239		Object:   "BugEdge",
 4240		Field:    field,
 4241		Args:     nil,
 4242		IsMethod: false,
 4243	}
 4244	ctx = graphql.WithResolverContext(ctx, rctx)
 4245	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4246	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4247		ctx = rctx // use context from middleware stack in children
 4248		return obj.Node, nil
 4249	})
 4250	if err != nil {
 4251		ec.Error(ctx, err)
 4252		return graphql.Null
 4253	}
 4254	if resTmp == nil {
 4255		if !ec.HasError(rctx) {
 4256			ec.Errorf(ctx, "must not be null")
 4257		}
 4258		return graphql.Null
 4259	}
 4260	res := resTmp.(*bug.Snapshot)
 4261	rctx.Result = res
 4262	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4263	return ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
 4264}
 4265
 4266func (ec *executionContext) _ChangeLabelPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
 4267	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4268	defer func() {
 4269		if r := recover(); r != nil {
 4270			ec.Error(ctx, ec.Recover(ctx, r))
 4271			ret = graphql.Null
 4272		}
 4273		ec.Tracer.EndFieldExecution(ctx)
 4274	}()
 4275	rctx := &graphql.ResolverContext{
 4276		Object:   "ChangeLabelPayload",
 4277		Field:    field,
 4278		Args:     nil,
 4279		IsMethod: false,
 4280	}
 4281	ctx = graphql.WithResolverContext(ctx, rctx)
 4282	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4283	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4284		ctx = rctx // use context from middleware stack in children
 4285		return obj.ClientMutationID, nil
 4286	})
 4287	if err != nil {
 4288		ec.Error(ctx, err)
 4289		return graphql.Null
 4290	}
 4291	if resTmp == nil {
 4292		return graphql.Null
 4293	}
 4294	res := resTmp.(*string)
 4295	rctx.Result = res
 4296	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4297	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 4298}
 4299
 4300func (ec *executionContext) _ChangeLabelPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
 4301	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4302	defer func() {
 4303		if r := recover(); r != nil {
 4304			ec.Error(ctx, ec.Recover(ctx, r))
 4305			ret = graphql.Null
 4306		}
 4307		ec.Tracer.EndFieldExecution(ctx)
 4308	}()
 4309	rctx := &graphql.ResolverContext{
 4310		Object:   "ChangeLabelPayload",
 4311		Field:    field,
 4312		Args:     nil,
 4313		IsMethod: false,
 4314	}
 4315	ctx = graphql.WithResolverContext(ctx, rctx)
 4316	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4317	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4318		ctx = rctx // use context from middleware stack in children
 4319		return obj.Bug, nil
 4320	})
 4321	if err != nil {
 4322		ec.Error(ctx, err)
 4323		return graphql.Null
 4324	}
 4325	if resTmp == nil {
 4326		if !ec.HasError(rctx) {
 4327			ec.Errorf(ctx, "must not be null")
 4328		}
 4329		return graphql.Null
 4330	}
 4331	res := resTmp.(*bug.Snapshot)
 4332	rctx.Result = res
 4333	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4334	return ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
 4335}
 4336
 4337func (ec *executionContext) _ChangeLabelPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
 4338	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4339	defer func() {
 4340		if r := recover(); r != nil {
 4341			ec.Error(ctx, ec.Recover(ctx, r))
 4342			ret = graphql.Null
 4343		}
 4344		ec.Tracer.EndFieldExecution(ctx)
 4345	}()
 4346	rctx := &graphql.ResolverContext{
 4347		Object:   "ChangeLabelPayload",
 4348		Field:    field,
 4349		Args:     nil,
 4350		IsMethod: false,
 4351	}
 4352	ctx = graphql.WithResolverContext(ctx, rctx)
 4353	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4354	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4355		ctx = rctx // use context from middleware stack in children
 4356		return obj.Operation, nil
 4357	})
 4358	if err != nil {
 4359		ec.Error(ctx, err)
 4360		return graphql.Null
 4361	}
 4362	if resTmp == nil {
 4363		if !ec.HasError(rctx) {
 4364			ec.Errorf(ctx, "must not be null")
 4365		}
 4366		return graphql.Null
 4367	}
 4368	res := resTmp.(*bug.LabelChangeOperation)
 4369	rctx.Result = res
 4370	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4371	return ec.marshalNLabelChangeOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeOperation(ctx, field.Selections, res)
 4372}
 4373
 4374func (ec *executionContext) _ChangeLabelPayload_results(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) (ret graphql.Marshaler) {
 4375	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4376	defer func() {
 4377		if r := recover(); r != nil {
 4378			ec.Error(ctx, ec.Recover(ctx, r))
 4379			ret = graphql.Null
 4380		}
 4381		ec.Tracer.EndFieldExecution(ctx)
 4382	}()
 4383	rctx := &graphql.ResolverContext{
 4384		Object:   "ChangeLabelPayload",
 4385		Field:    field,
 4386		Args:     nil,
 4387		IsMethod: false,
 4388	}
 4389	ctx = graphql.WithResolverContext(ctx, rctx)
 4390	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4391	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4392		ctx = rctx // use context from middleware stack in children
 4393		return obj.Results, nil
 4394	})
 4395	if err != nil {
 4396		ec.Error(ctx, err)
 4397		return graphql.Null
 4398	}
 4399	if resTmp == nil {
 4400		if !ec.HasError(rctx) {
 4401			ec.Errorf(ctx, "must not be null")
 4402		}
 4403		return graphql.Null
 4404	}
 4405	res := resTmp.([]*bug.LabelChangeResult)
 4406	rctx.Result = res
 4407	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4408	return ec.marshalNLabelChangeResult2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx, field.Selections, res)
 4409}
 4410
 4411func (ec *executionContext) _CloseBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) (ret graphql.Marshaler) {
 4412	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4413	defer func() {
 4414		if r := recover(); r != nil {
 4415			ec.Error(ctx, ec.Recover(ctx, r))
 4416			ret = graphql.Null
 4417		}
 4418		ec.Tracer.EndFieldExecution(ctx)
 4419	}()
 4420	rctx := &graphql.ResolverContext{
 4421		Object:   "CloseBugPayload",
 4422		Field:    field,
 4423		Args:     nil,
 4424		IsMethod: false,
 4425	}
 4426	ctx = graphql.WithResolverContext(ctx, rctx)
 4427	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4428	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4429		ctx = rctx // use context from middleware stack in children
 4430		return obj.ClientMutationID, nil
 4431	})
 4432	if err != nil {
 4433		ec.Error(ctx, err)
 4434		return graphql.Null
 4435	}
 4436	if resTmp == nil {
 4437		return graphql.Null
 4438	}
 4439	res := resTmp.(*string)
 4440	rctx.Result = res
 4441	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4442	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 4443}
 4444
 4445func (ec *executionContext) _CloseBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) (ret graphql.Marshaler) {
 4446	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4447	defer func() {
 4448		if r := recover(); r != nil {
 4449			ec.Error(ctx, ec.Recover(ctx, r))
 4450			ret = graphql.Null
 4451		}
 4452		ec.Tracer.EndFieldExecution(ctx)
 4453	}()
 4454	rctx := &graphql.ResolverContext{
 4455		Object:   "CloseBugPayload",
 4456		Field:    field,
 4457		Args:     nil,
 4458		IsMethod: false,
 4459	}
 4460	ctx = graphql.WithResolverContext(ctx, rctx)
 4461	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4462	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4463		ctx = rctx // use context from middleware stack in children
 4464		return obj.Bug, nil
 4465	})
 4466	if err != nil {
 4467		ec.Error(ctx, err)
 4468		return graphql.Null
 4469	}
 4470	if resTmp == nil {
 4471		if !ec.HasError(rctx) {
 4472			ec.Errorf(ctx, "must not be null")
 4473		}
 4474		return graphql.Null
 4475	}
 4476	res := resTmp.(*bug.Snapshot)
 4477	rctx.Result = res
 4478	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4479	return ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
 4480}
 4481
 4482func (ec *executionContext) _CloseBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) (ret graphql.Marshaler) {
 4483	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4484	defer func() {
 4485		if r := recover(); r != nil {
 4486			ec.Error(ctx, ec.Recover(ctx, r))
 4487			ret = graphql.Null
 4488		}
 4489		ec.Tracer.EndFieldExecution(ctx)
 4490	}()
 4491	rctx := &graphql.ResolverContext{
 4492		Object:   "CloseBugPayload",
 4493		Field:    field,
 4494		Args:     nil,
 4495		IsMethod: false,
 4496	}
 4497	ctx = graphql.WithResolverContext(ctx, rctx)
 4498	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4499	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4500		ctx = rctx // use context from middleware stack in children
 4501		return obj.Operation, nil
 4502	})
 4503	if err != nil {
 4504		ec.Error(ctx, err)
 4505		return graphql.Null
 4506	}
 4507	if resTmp == nil {
 4508		if !ec.HasError(rctx) {
 4509			ec.Errorf(ctx, "must not be null")
 4510		}
 4511		return graphql.Null
 4512	}
 4513	res := resTmp.(*bug.SetStatusOperation)
 4514	rctx.Result = res
 4515	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4516	return ec.marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
 4517}
 4518
 4519func (ec *executionContext) _Color_R(ctx context.Context, field graphql.CollectedField, obj *color.RGBA) (ret graphql.Marshaler) {
 4520	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4521	defer func() {
 4522		if r := recover(); r != nil {
 4523			ec.Error(ctx, ec.Recover(ctx, r))
 4524			ret = graphql.Null
 4525		}
 4526		ec.Tracer.EndFieldExecution(ctx)
 4527	}()
 4528	rctx := &graphql.ResolverContext{
 4529		Object:   "Color",
 4530		Field:    field,
 4531		Args:     nil,
 4532		IsMethod: true,
 4533	}
 4534	ctx = graphql.WithResolverContext(ctx, rctx)
 4535	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4536	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4537		ctx = rctx // use context from middleware stack in children
 4538		return ec.resolvers.Color().R(rctx, obj)
 4539	})
 4540	if err != nil {
 4541		ec.Error(ctx, err)
 4542		return graphql.Null
 4543	}
 4544	if resTmp == nil {
 4545		if !ec.HasError(rctx) {
 4546			ec.Errorf(ctx, "must not be null")
 4547		}
 4548		return graphql.Null
 4549	}
 4550	res := resTmp.(int)
 4551	rctx.Result = res
 4552	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4553	return ec.marshalNInt2int(ctx, field.Selections, res)
 4554}
 4555
 4556func (ec *executionContext) _Color_G(ctx context.Context, field graphql.CollectedField, obj *color.RGBA) (ret graphql.Marshaler) {
 4557	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4558	defer func() {
 4559		if r := recover(); r != nil {
 4560			ec.Error(ctx, ec.Recover(ctx, r))
 4561			ret = graphql.Null
 4562		}
 4563		ec.Tracer.EndFieldExecution(ctx)
 4564	}()
 4565	rctx := &graphql.ResolverContext{
 4566		Object:   "Color",
 4567		Field:    field,
 4568		Args:     nil,
 4569		IsMethod: true,
 4570	}
 4571	ctx = graphql.WithResolverContext(ctx, rctx)
 4572	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4573	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4574		ctx = rctx // use context from middleware stack in children
 4575		return ec.resolvers.Color().G(rctx, obj)
 4576	})
 4577	if err != nil {
 4578		ec.Error(ctx, err)
 4579		return graphql.Null
 4580	}
 4581	if resTmp == nil {
 4582		if !ec.HasError(rctx) {
 4583			ec.Errorf(ctx, "must not be null")
 4584		}
 4585		return graphql.Null
 4586	}
 4587	res := resTmp.(int)
 4588	rctx.Result = res
 4589	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4590	return ec.marshalNInt2int(ctx, field.Selections, res)
 4591}
 4592
 4593func (ec *executionContext) _Color_B(ctx context.Context, field graphql.CollectedField, obj *color.RGBA) (ret graphql.Marshaler) {
 4594	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4595	defer func() {
 4596		if r := recover(); r != nil {
 4597			ec.Error(ctx, ec.Recover(ctx, r))
 4598			ret = graphql.Null
 4599		}
 4600		ec.Tracer.EndFieldExecution(ctx)
 4601	}()
 4602	rctx := &graphql.ResolverContext{
 4603		Object:   "Color",
 4604		Field:    field,
 4605		Args:     nil,
 4606		IsMethod: true,
 4607	}
 4608	ctx = graphql.WithResolverContext(ctx, rctx)
 4609	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4610	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4611		ctx = rctx // use context from middleware stack in children
 4612		return ec.resolvers.Color().B(rctx, obj)
 4613	})
 4614	if err != nil {
 4615		ec.Error(ctx, err)
 4616		return graphql.Null
 4617	}
 4618	if resTmp == nil {
 4619		if !ec.HasError(rctx) {
 4620			ec.Errorf(ctx, "must not be null")
 4621		}
 4622		return graphql.Null
 4623	}
 4624	res := resTmp.(int)
 4625	rctx.Result = res
 4626	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4627	return ec.marshalNInt2int(ctx, field.Selections, res)
 4628}
 4629
 4630func (ec *executionContext) _Comment_author(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
 4631	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4632	defer func() {
 4633		if r := recover(); r != nil {
 4634			ec.Error(ctx, ec.Recover(ctx, r))
 4635			ret = graphql.Null
 4636		}
 4637		ec.Tracer.EndFieldExecution(ctx)
 4638	}()
 4639	rctx := &graphql.ResolverContext{
 4640		Object:   "Comment",
 4641		Field:    field,
 4642		Args:     nil,
 4643		IsMethod: false,
 4644	}
 4645	ctx = graphql.WithResolverContext(ctx, rctx)
 4646	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4647	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4648		ctx = rctx // use context from middleware stack in children
 4649		return obj.Author, nil
 4650	})
 4651	if err != nil {
 4652		ec.Error(ctx, err)
 4653		return graphql.Null
 4654	}
 4655	if resTmp == nil {
 4656		if !ec.HasError(rctx) {
 4657			ec.Errorf(ctx, "must not be null")
 4658		}
 4659		return graphql.Null
 4660	}
 4661	res := resTmp.(identity.Interface)
 4662	rctx.Result = res
 4663	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4664	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
 4665}
 4666
 4667func (ec *executionContext) _Comment_message(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
 4668	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4669	defer func() {
 4670		if r := recover(); r != nil {
 4671			ec.Error(ctx, ec.Recover(ctx, r))
 4672			ret = graphql.Null
 4673		}
 4674		ec.Tracer.EndFieldExecution(ctx)
 4675	}()
 4676	rctx := &graphql.ResolverContext{
 4677		Object:   "Comment",
 4678		Field:    field,
 4679		Args:     nil,
 4680		IsMethod: false,
 4681	}
 4682	ctx = graphql.WithResolverContext(ctx, rctx)
 4683	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4684	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4685		ctx = rctx // use context from middleware stack in children
 4686		return obj.Message, nil
 4687	})
 4688	if err != nil {
 4689		ec.Error(ctx, err)
 4690		return graphql.Null
 4691	}
 4692	if resTmp == nil {
 4693		if !ec.HasError(rctx) {
 4694			ec.Errorf(ctx, "must not be null")
 4695		}
 4696		return graphql.Null
 4697	}
 4698	res := resTmp.(string)
 4699	rctx.Result = res
 4700	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4701	return ec.marshalNString2string(ctx, field.Selections, res)
 4702}
 4703
 4704func (ec *executionContext) _Comment_files(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) (ret graphql.Marshaler) {
 4705	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4706	defer func() {
 4707		if r := recover(); r != nil {
 4708			ec.Error(ctx, ec.Recover(ctx, r))
 4709			ret = graphql.Null
 4710		}
 4711		ec.Tracer.EndFieldExecution(ctx)
 4712	}()
 4713	rctx := &graphql.ResolverContext{
 4714		Object:   "Comment",
 4715		Field:    field,
 4716		Args:     nil,
 4717		IsMethod: false,
 4718	}
 4719	ctx = graphql.WithResolverContext(ctx, rctx)
 4720	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4721	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4722		ctx = rctx // use context from middleware stack in children
 4723		return obj.Files, nil
 4724	})
 4725	if err != nil {
 4726		ec.Error(ctx, err)
 4727		return graphql.Null
 4728	}
 4729	if resTmp == nil {
 4730		if !ec.HasError(rctx) {
 4731			ec.Errorf(ctx, "must not be null")
 4732		}
 4733		return graphql.Null
 4734	}
 4735	res := resTmp.([]git.Hash)
 4736	rctx.Result = res
 4737	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4738	return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
 4739}
 4740
 4741func (ec *executionContext) _CommentConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
 4742	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4743	defer func() {
 4744		if r := recover(); r != nil {
 4745			ec.Error(ctx, ec.Recover(ctx, r))
 4746			ret = graphql.Null
 4747		}
 4748		ec.Tracer.EndFieldExecution(ctx)
 4749	}()
 4750	rctx := &graphql.ResolverContext{
 4751		Object:   "CommentConnection",
 4752		Field:    field,
 4753		Args:     nil,
 4754		IsMethod: false,
 4755	}
 4756	ctx = graphql.WithResolverContext(ctx, rctx)
 4757	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4758	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4759		ctx = rctx // use context from middleware stack in children
 4760		return obj.Edges, nil
 4761	})
 4762	if err != nil {
 4763		ec.Error(ctx, err)
 4764		return graphql.Null
 4765	}
 4766	if resTmp == nil {
 4767		if !ec.HasError(rctx) {
 4768			ec.Errorf(ctx, "must not be null")
 4769		}
 4770		return graphql.Null
 4771	}
 4772	res := resTmp.([]*models.CommentEdge)
 4773	rctx.Result = res
 4774	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4775	return ec.marshalNCommentEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx, field.Selections, res)
 4776}
 4777
 4778func (ec *executionContext) _CommentConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
 4779	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4780	defer func() {
 4781		if r := recover(); r != nil {
 4782			ec.Error(ctx, ec.Recover(ctx, r))
 4783			ret = graphql.Null
 4784		}
 4785		ec.Tracer.EndFieldExecution(ctx)
 4786	}()
 4787	rctx := &graphql.ResolverContext{
 4788		Object:   "CommentConnection",
 4789		Field:    field,
 4790		Args:     nil,
 4791		IsMethod: false,
 4792	}
 4793	ctx = graphql.WithResolverContext(ctx, rctx)
 4794	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4795	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4796		ctx = rctx // use context from middleware stack in children
 4797		return obj.Nodes, nil
 4798	})
 4799	if err != nil {
 4800		ec.Error(ctx, err)
 4801		return graphql.Null
 4802	}
 4803	if resTmp == nil {
 4804		if !ec.HasError(rctx) {
 4805			ec.Errorf(ctx, "must not be null")
 4806		}
 4807		return graphql.Null
 4808	}
 4809	res := resTmp.([]*bug.Comment)
 4810	rctx.Result = res
 4811	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4812	return ec.marshalNComment2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx, field.Selections, res)
 4813}
 4814
 4815func (ec *executionContext) _CommentConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
 4816	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4817	defer func() {
 4818		if r := recover(); r != nil {
 4819			ec.Error(ctx, ec.Recover(ctx, r))
 4820			ret = graphql.Null
 4821		}
 4822		ec.Tracer.EndFieldExecution(ctx)
 4823	}()
 4824	rctx := &graphql.ResolverContext{
 4825		Object:   "CommentConnection",
 4826		Field:    field,
 4827		Args:     nil,
 4828		IsMethod: false,
 4829	}
 4830	ctx = graphql.WithResolverContext(ctx, rctx)
 4831	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4832	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4833		ctx = rctx // use context from middleware stack in children
 4834		return obj.PageInfo, nil
 4835	})
 4836	if err != nil {
 4837		ec.Error(ctx, err)
 4838		return graphql.Null
 4839	}
 4840	if resTmp == nil {
 4841		if !ec.HasError(rctx) {
 4842			ec.Errorf(ctx, "must not be null")
 4843		}
 4844		return graphql.Null
 4845	}
 4846	res := resTmp.(*models.PageInfo)
 4847	rctx.Result = res
 4848	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4849	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
 4850}
 4851
 4852func (ec *executionContext) _CommentConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) (ret graphql.Marshaler) {
 4853	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4854	defer func() {
 4855		if r := recover(); r != nil {
 4856			ec.Error(ctx, ec.Recover(ctx, r))
 4857			ret = graphql.Null
 4858		}
 4859		ec.Tracer.EndFieldExecution(ctx)
 4860	}()
 4861	rctx := &graphql.ResolverContext{
 4862		Object:   "CommentConnection",
 4863		Field:    field,
 4864		Args:     nil,
 4865		IsMethod: false,
 4866	}
 4867	ctx = graphql.WithResolverContext(ctx, rctx)
 4868	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4869	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4870		ctx = rctx // use context from middleware stack in children
 4871		return obj.TotalCount, nil
 4872	})
 4873	if err != nil {
 4874		ec.Error(ctx, err)
 4875		return graphql.Null
 4876	}
 4877	if resTmp == nil {
 4878		if !ec.HasError(rctx) {
 4879			ec.Errorf(ctx, "must not be null")
 4880		}
 4881		return graphql.Null
 4882	}
 4883	res := resTmp.(int)
 4884	rctx.Result = res
 4885	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4886	return ec.marshalNInt2int(ctx, field.Selections, res)
 4887}
 4888
 4889func (ec *executionContext) _CommentEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.CommentEdge) (ret graphql.Marshaler) {
 4890	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4891	defer func() {
 4892		if r := recover(); r != nil {
 4893			ec.Error(ctx, ec.Recover(ctx, r))
 4894			ret = graphql.Null
 4895		}
 4896		ec.Tracer.EndFieldExecution(ctx)
 4897	}()
 4898	rctx := &graphql.ResolverContext{
 4899		Object:   "CommentEdge",
 4900		Field:    field,
 4901		Args:     nil,
 4902		IsMethod: false,
 4903	}
 4904	ctx = graphql.WithResolverContext(ctx, rctx)
 4905	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4906	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4907		ctx = rctx // use context from middleware stack in children
 4908		return obj.Cursor, nil
 4909	})
 4910	if err != nil {
 4911		ec.Error(ctx, err)
 4912		return graphql.Null
 4913	}
 4914	if resTmp == nil {
 4915		if !ec.HasError(rctx) {
 4916			ec.Errorf(ctx, "must not be null")
 4917		}
 4918		return graphql.Null
 4919	}
 4920	res := resTmp.(string)
 4921	rctx.Result = res
 4922	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4923	return ec.marshalNString2string(ctx, field.Selections, res)
 4924}
 4925
 4926func (ec *executionContext) _CommentEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.CommentEdge) (ret graphql.Marshaler) {
 4927	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4928	defer func() {
 4929		if r := recover(); r != nil {
 4930			ec.Error(ctx, ec.Recover(ctx, r))
 4931			ret = graphql.Null
 4932		}
 4933		ec.Tracer.EndFieldExecution(ctx)
 4934	}()
 4935	rctx := &graphql.ResolverContext{
 4936		Object:   "CommentEdge",
 4937		Field:    field,
 4938		Args:     nil,
 4939		IsMethod: false,
 4940	}
 4941	ctx = graphql.WithResolverContext(ctx, rctx)
 4942	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4943	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4944		ctx = rctx // use context from middleware stack in children
 4945		return obj.Node, nil
 4946	})
 4947	if err != nil {
 4948		ec.Error(ctx, err)
 4949		return graphql.Null
 4950	}
 4951	if resTmp == nil {
 4952		if !ec.HasError(rctx) {
 4953			ec.Errorf(ctx, "must not be null")
 4954		}
 4955		return graphql.Null
 4956	}
 4957	res := resTmp.(*bug.Comment)
 4958	rctx.Result = res
 4959	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4960	return ec.marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx, field.Selections, res)
 4961}
 4962
 4963func (ec *executionContext) _CommentHistoryStep_message(ctx context.Context, field graphql.CollectedField, obj *bug.CommentHistoryStep) (ret graphql.Marshaler) {
 4964	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4965	defer func() {
 4966		if r := recover(); r != nil {
 4967			ec.Error(ctx, ec.Recover(ctx, r))
 4968			ret = graphql.Null
 4969		}
 4970		ec.Tracer.EndFieldExecution(ctx)
 4971	}()
 4972	rctx := &graphql.ResolverContext{
 4973		Object:   "CommentHistoryStep",
 4974		Field:    field,
 4975		Args:     nil,
 4976		IsMethod: false,
 4977	}
 4978	ctx = graphql.WithResolverContext(ctx, rctx)
 4979	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4980	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 4981		ctx = rctx // use context from middleware stack in children
 4982		return obj.Message, nil
 4983	})
 4984	if err != nil {
 4985		ec.Error(ctx, err)
 4986		return graphql.Null
 4987	}
 4988	if resTmp == nil {
 4989		if !ec.HasError(rctx) {
 4990			ec.Errorf(ctx, "must not be null")
 4991		}
 4992		return graphql.Null
 4993	}
 4994	res := resTmp.(string)
 4995	rctx.Result = res
 4996	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4997	return ec.marshalNString2string(ctx, field.Selections, res)
 4998}
 4999
 5000func (ec *executionContext) _CommentHistoryStep_date(ctx context.Context, field graphql.CollectedField, obj *bug.CommentHistoryStep) (ret graphql.Marshaler) {
 5001	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5002	defer func() {
 5003		if r := recover(); r != nil {
 5004			ec.Error(ctx, ec.Recover(ctx, r))
 5005			ret = graphql.Null
 5006		}
 5007		ec.Tracer.EndFieldExecution(ctx)
 5008	}()
 5009	rctx := &graphql.ResolverContext{
 5010		Object:   "CommentHistoryStep",
 5011		Field:    field,
 5012		Args:     nil,
 5013		IsMethod: true,
 5014	}
 5015	ctx = graphql.WithResolverContext(ctx, rctx)
 5016	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5017	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5018		ctx = rctx // use context from middleware stack in children
 5019		return ec.resolvers.CommentHistoryStep().Date(rctx, obj)
 5020	})
 5021	if err != nil {
 5022		ec.Error(ctx, err)
 5023		return graphql.Null
 5024	}
 5025	if resTmp == nil {
 5026		if !ec.HasError(rctx) {
 5027			ec.Errorf(ctx, "must not be null")
 5028		}
 5029		return graphql.Null
 5030	}
 5031	res := resTmp.(*time.Time)
 5032	rctx.Result = res
 5033	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5034	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 5035}
 5036
 5037func (ec *executionContext) _CommitAsNeededPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.CommitAsNeededPayload) (ret graphql.Marshaler) {
 5038	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5039	defer func() {
 5040		if r := recover(); r != nil {
 5041			ec.Error(ctx, ec.Recover(ctx, r))
 5042			ret = graphql.Null
 5043		}
 5044		ec.Tracer.EndFieldExecution(ctx)
 5045	}()
 5046	rctx := &graphql.ResolverContext{
 5047		Object:   "CommitAsNeededPayload",
 5048		Field:    field,
 5049		Args:     nil,
 5050		IsMethod: false,
 5051	}
 5052	ctx = graphql.WithResolverContext(ctx, rctx)
 5053	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5054	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5055		ctx = rctx // use context from middleware stack in children
 5056		return obj.ClientMutationID, nil
 5057	})
 5058	if err != nil {
 5059		ec.Error(ctx, err)
 5060		return graphql.Null
 5061	}
 5062	if resTmp == nil {
 5063		return graphql.Null
 5064	}
 5065	res := resTmp.(*string)
 5066	rctx.Result = res
 5067	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5068	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 5069}
 5070
 5071func (ec *executionContext) _CommitAsNeededPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.CommitAsNeededPayload) (ret graphql.Marshaler) {
 5072	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5073	defer func() {
 5074		if r := recover(); r != nil {
 5075			ec.Error(ctx, ec.Recover(ctx, r))
 5076			ret = graphql.Null
 5077		}
 5078		ec.Tracer.EndFieldExecution(ctx)
 5079	}()
 5080	rctx := &graphql.ResolverContext{
 5081		Object:   "CommitAsNeededPayload",
 5082		Field:    field,
 5083		Args:     nil,
 5084		IsMethod: false,
 5085	}
 5086	ctx = graphql.WithResolverContext(ctx, rctx)
 5087	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5088	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5089		ctx = rctx // use context from middleware stack in children
 5090		return obj.Bug, nil
 5091	})
 5092	if err != nil {
 5093		ec.Error(ctx, err)
 5094		return graphql.Null
 5095	}
 5096	if resTmp == nil {
 5097		if !ec.HasError(rctx) {
 5098			ec.Errorf(ctx, "must not be null")
 5099		}
 5100		return graphql.Null
 5101	}
 5102	res := resTmp.(*bug.Snapshot)
 5103	rctx.Result = res
 5104	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5105	return ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
 5106}
 5107
 5108func (ec *executionContext) _CommitPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.CommitPayload) (ret graphql.Marshaler) {
 5109	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5110	defer func() {
 5111		if r := recover(); r != nil {
 5112			ec.Error(ctx, ec.Recover(ctx, r))
 5113			ret = graphql.Null
 5114		}
 5115		ec.Tracer.EndFieldExecution(ctx)
 5116	}()
 5117	rctx := &graphql.ResolverContext{
 5118		Object:   "CommitPayload",
 5119		Field:    field,
 5120		Args:     nil,
 5121		IsMethod: false,
 5122	}
 5123	ctx = graphql.WithResolverContext(ctx, rctx)
 5124	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5125	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5126		ctx = rctx // use context from middleware stack in children
 5127		return obj.ClientMutationID, nil
 5128	})
 5129	if err != nil {
 5130		ec.Error(ctx, err)
 5131		return graphql.Null
 5132	}
 5133	if resTmp == nil {
 5134		return graphql.Null
 5135	}
 5136	res := resTmp.(*string)
 5137	rctx.Result = res
 5138	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5139	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 5140}
 5141
 5142func (ec *executionContext) _CommitPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.CommitPayload) (ret graphql.Marshaler) {
 5143	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5144	defer func() {
 5145		if r := recover(); r != nil {
 5146			ec.Error(ctx, ec.Recover(ctx, r))
 5147			ret = graphql.Null
 5148		}
 5149		ec.Tracer.EndFieldExecution(ctx)
 5150	}()
 5151	rctx := &graphql.ResolverContext{
 5152		Object:   "CommitPayload",
 5153		Field:    field,
 5154		Args:     nil,
 5155		IsMethod: false,
 5156	}
 5157	ctx = graphql.WithResolverContext(ctx, rctx)
 5158	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5159	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5160		ctx = rctx // use context from middleware stack in children
 5161		return obj.Bug, nil
 5162	})
 5163	if err != nil {
 5164		ec.Error(ctx, err)
 5165		return graphql.Null
 5166	}
 5167	if resTmp == nil {
 5168		if !ec.HasError(rctx) {
 5169			ec.Errorf(ctx, "must not be null")
 5170		}
 5171		return graphql.Null
 5172	}
 5173	res := resTmp.(*bug.Snapshot)
 5174	rctx.Result = res
 5175	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5176	return ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
 5177}
 5178
 5179func (ec *executionContext) _CreateOperation_hash(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
 5180	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5181	defer func() {
 5182		if r := recover(); r != nil {
 5183			ec.Error(ctx, ec.Recover(ctx, r))
 5184			ret = graphql.Null
 5185		}
 5186		ec.Tracer.EndFieldExecution(ctx)
 5187	}()
 5188	rctx := &graphql.ResolverContext{
 5189		Object:   "CreateOperation",
 5190		Field:    field,
 5191		Args:     nil,
 5192		IsMethod: true,
 5193	}
 5194	ctx = graphql.WithResolverContext(ctx, rctx)
 5195	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5196	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5197		ctx = rctx // use context from middleware stack in children
 5198		return obj.Hash()
 5199	})
 5200	if err != nil {
 5201		ec.Error(ctx, err)
 5202		return graphql.Null
 5203	}
 5204	if resTmp == nil {
 5205		if !ec.HasError(rctx) {
 5206			ec.Errorf(ctx, "must not be null")
 5207		}
 5208		return graphql.Null
 5209	}
 5210	res := resTmp.(git.Hash)
 5211	rctx.Result = res
 5212	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5213	return ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
 5214}
 5215
 5216func (ec *executionContext) _CreateOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
 5217	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5218	defer func() {
 5219		if r := recover(); r != nil {
 5220			ec.Error(ctx, ec.Recover(ctx, r))
 5221			ret = graphql.Null
 5222		}
 5223		ec.Tracer.EndFieldExecution(ctx)
 5224	}()
 5225	rctx := &graphql.ResolverContext{
 5226		Object:   "CreateOperation",
 5227		Field:    field,
 5228		Args:     nil,
 5229		IsMethod: false,
 5230	}
 5231	ctx = graphql.WithResolverContext(ctx, rctx)
 5232	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5233	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5234		ctx = rctx // use context from middleware stack in children
 5235		return obj.Author, nil
 5236	})
 5237	if err != nil {
 5238		ec.Error(ctx, err)
 5239		return graphql.Null
 5240	}
 5241	if resTmp == nil {
 5242		if !ec.HasError(rctx) {
 5243			ec.Errorf(ctx, "must not be null")
 5244		}
 5245		return graphql.Null
 5246	}
 5247	res := resTmp.(identity.Interface)
 5248	rctx.Result = res
 5249	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5250	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
 5251}
 5252
 5253func (ec *executionContext) _CreateOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
 5254	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5255	defer func() {
 5256		if r := recover(); r != nil {
 5257			ec.Error(ctx, ec.Recover(ctx, r))
 5258			ret = graphql.Null
 5259		}
 5260		ec.Tracer.EndFieldExecution(ctx)
 5261	}()
 5262	rctx := &graphql.ResolverContext{
 5263		Object:   "CreateOperation",
 5264		Field:    field,
 5265		Args:     nil,
 5266		IsMethod: true,
 5267	}
 5268	ctx = graphql.WithResolverContext(ctx, rctx)
 5269	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5270	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5271		ctx = rctx // use context from middleware stack in children
 5272		return ec.resolvers.CreateOperation().Date(rctx, obj)
 5273	})
 5274	if err != nil {
 5275		ec.Error(ctx, err)
 5276		return graphql.Null
 5277	}
 5278	if resTmp == nil {
 5279		if !ec.HasError(rctx) {
 5280			ec.Errorf(ctx, "must not be null")
 5281		}
 5282		return graphql.Null
 5283	}
 5284	res := resTmp.(*time.Time)
 5285	rctx.Result = res
 5286	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5287	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 5288}
 5289
 5290func (ec *executionContext) _CreateOperation_title(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
 5291	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5292	defer func() {
 5293		if r := recover(); r != nil {
 5294			ec.Error(ctx, ec.Recover(ctx, r))
 5295			ret = graphql.Null
 5296		}
 5297		ec.Tracer.EndFieldExecution(ctx)
 5298	}()
 5299	rctx := &graphql.ResolverContext{
 5300		Object:   "CreateOperation",
 5301		Field:    field,
 5302		Args:     nil,
 5303		IsMethod: false,
 5304	}
 5305	ctx = graphql.WithResolverContext(ctx, rctx)
 5306	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5307	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5308		ctx = rctx // use context from middleware stack in children
 5309		return obj.Title, nil
 5310	})
 5311	if err != nil {
 5312		ec.Error(ctx, err)
 5313		return graphql.Null
 5314	}
 5315	if resTmp == nil {
 5316		if !ec.HasError(rctx) {
 5317			ec.Errorf(ctx, "must not be null")
 5318		}
 5319		return graphql.Null
 5320	}
 5321	res := resTmp.(string)
 5322	rctx.Result = res
 5323	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5324	return ec.marshalNString2string(ctx, field.Selections, res)
 5325}
 5326
 5327func (ec *executionContext) _CreateOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
 5328	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5329	defer func() {
 5330		if r := recover(); r != nil {
 5331			ec.Error(ctx, ec.Recover(ctx, r))
 5332			ret = graphql.Null
 5333		}
 5334		ec.Tracer.EndFieldExecution(ctx)
 5335	}()
 5336	rctx := &graphql.ResolverContext{
 5337		Object:   "CreateOperation",
 5338		Field:    field,
 5339		Args:     nil,
 5340		IsMethod: false,
 5341	}
 5342	ctx = graphql.WithResolverContext(ctx, rctx)
 5343	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5344	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5345		ctx = rctx // use context from middleware stack in children
 5346		return obj.Message, nil
 5347	})
 5348	if err != nil {
 5349		ec.Error(ctx, err)
 5350		return graphql.Null
 5351	}
 5352	if resTmp == nil {
 5353		if !ec.HasError(rctx) {
 5354			ec.Errorf(ctx, "must not be null")
 5355		}
 5356		return graphql.Null
 5357	}
 5358	res := resTmp.(string)
 5359	rctx.Result = res
 5360	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5361	return ec.marshalNString2string(ctx, field.Selections, res)
 5362}
 5363
 5364func (ec *executionContext) _CreateOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) (ret graphql.Marshaler) {
 5365	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5366	defer func() {
 5367		if r := recover(); r != nil {
 5368			ec.Error(ctx, ec.Recover(ctx, r))
 5369			ret = graphql.Null
 5370		}
 5371		ec.Tracer.EndFieldExecution(ctx)
 5372	}()
 5373	rctx := &graphql.ResolverContext{
 5374		Object:   "CreateOperation",
 5375		Field:    field,
 5376		Args:     nil,
 5377		IsMethod: false,
 5378	}
 5379	ctx = graphql.WithResolverContext(ctx, rctx)
 5380	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5381	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5382		ctx = rctx // use context from middleware stack in children
 5383		return obj.Files, nil
 5384	})
 5385	if err != nil {
 5386		ec.Error(ctx, err)
 5387		return graphql.Null
 5388	}
 5389	if resTmp == nil {
 5390		if !ec.HasError(rctx) {
 5391			ec.Errorf(ctx, "must not be null")
 5392		}
 5393		return graphql.Null
 5394	}
 5395	res := resTmp.([]git.Hash)
 5396	rctx.Result = res
 5397	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5398	return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
 5399}
 5400
 5401func (ec *executionContext) _CreateTimelineItem_hash(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5402	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5403	defer func() {
 5404		if r := recover(); r != nil {
 5405			ec.Error(ctx, ec.Recover(ctx, r))
 5406			ret = graphql.Null
 5407		}
 5408		ec.Tracer.EndFieldExecution(ctx)
 5409	}()
 5410	rctx := &graphql.ResolverContext{
 5411		Object:   "CreateTimelineItem",
 5412		Field:    field,
 5413		Args:     nil,
 5414		IsMethod: true,
 5415	}
 5416	ctx = graphql.WithResolverContext(ctx, rctx)
 5417	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5418	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5419		ctx = rctx // use context from middleware stack in children
 5420		return obj.Hash(), nil
 5421	})
 5422	if err != nil {
 5423		ec.Error(ctx, err)
 5424		return graphql.Null
 5425	}
 5426	if resTmp == nil {
 5427		if !ec.HasError(rctx) {
 5428			ec.Errorf(ctx, "must not be null")
 5429		}
 5430		return graphql.Null
 5431	}
 5432	res := resTmp.(git.Hash)
 5433	rctx.Result = res
 5434	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5435	return ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
 5436}
 5437
 5438func (ec *executionContext) _CreateTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5439	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5440	defer func() {
 5441		if r := recover(); r != nil {
 5442			ec.Error(ctx, ec.Recover(ctx, r))
 5443			ret = graphql.Null
 5444		}
 5445		ec.Tracer.EndFieldExecution(ctx)
 5446	}()
 5447	rctx := &graphql.ResolverContext{
 5448		Object:   "CreateTimelineItem",
 5449		Field:    field,
 5450		Args:     nil,
 5451		IsMethod: false,
 5452	}
 5453	ctx = graphql.WithResolverContext(ctx, rctx)
 5454	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5455	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5456		ctx = rctx // use context from middleware stack in children
 5457		return obj.Author, nil
 5458	})
 5459	if err != nil {
 5460		ec.Error(ctx, err)
 5461		return graphql.Null
 5462	}
 5463	if resTmp == nil {
 5464		if !ec.HasError(rctx) {
 5465			ec.Errorf(ctx, "must not be null")
 5466		}
 5467		return graphql.Null
 5468	}
 5469	res := resTmp.(identity.Interface)
 5470	rctx.Result = res
 5471	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5472	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
 5473}
 5474
 5475func (ec *executionContext) _CreateTimelineItem_message(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5476	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5477	defer func() {
 5478		if r := recover(); r != nil {
 5479			ec.Error(ctx, ec.Recover(ctx, r))
 5480			ret = graphql.Null
 5481		}
 5482		ec.Tracer.EndFieldExecution(ctx)
 5483	}()
 5484	rctx := &graphql.ResolverContext{
 5485		Object:   "CreateTimelineItem",
 5486		Field:    field,
 5487		Args:     nil,
 5488		IsMethod: false,
 5489	}
 5490	ctx = graphql.WithResolverContext(ctx, rctx)
 5491	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5492	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5493		ctx = rctx // use context from middleware stack in children
 5494		return obj.Message, nil
 5495	})
 5496	if err != nil {
 5497		ec.Error(ctx, err)
 5498		return graphql.Null
 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.(string)
 5507	rctx.Result = res
 5508	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5509	return ec.marshalNString2string(ctx, field.Selections, res)
 5510}
 5511
 5512func (ec *executionContext) _CreateTimelineItem_messageIsEmpty(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5513	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5514	defer func() {
 5515		if r := recover(); r != nil {
 5516			ec.Error(ctx, ec.Recover(ctx, r))
 5517			ret = graphql.Null
 5518		}
 5519		ec.Tracer.EndFieldExecution(ctx)
 5520	}()
 5521	rctx := &graphql.ResolverContext{
 5522		Object:   "CreateTimelineItem",
 5523		Field:    field,
 5524		Args:     nil,
 5525		IsMethod: true,
 5526	}
 5527	ctx = graphql.WithResolverContext(ctx, rctx)
 5528	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5529	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5530		ctx = rctx // use context from middleware stack in children
 5531		return obj.MessageIsEmpty(), nil
 5532	})
 5533	if err != nil {
 5534		ec.Error(ctx, err)
 5535		return graphql.Null
 5536	}
 5537	if resTmp == nil {
 5538		if !ec.HasError(rctx) {
 5539			ec.Errorf(ctx, "must not be null")
 5540		}
 5541		return graphql.Null
 5542	}
 5543	res := resTmp.(bool)
 5544	rctx.Result = res
 5545	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5546	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 5547}
 5548
 5549func (ec *executionContext) _CreateTimelineItem_files(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5550	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5551	defer func() {
 5552		if r := recover(); r != nil {
 5553			ec.Error(ctx, ec.Recover(ctx, r))
 5554			ret = graphql.Null
 5555		}
 5556		ec.Tracer.EndFieldExecution(ctx)
 5557	}()
 5558	rctx := &graphql.ResolverContext{
 5559		Object:   "CreateTimelineItem",
 5560		Field:    field,
 5561		Args:     nil,
 5562		IsMethod: false,
 5563	}
 5564	ctx = graphql.WithResolverContext(ctx, rctx)
 5565	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5566	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5567		ctx = rctx // use context from middleware stack in children
 5568		return obj.Files, nil
 5569	})
 5570	if err != nil {
 5571		ec.Error(ctx, err)
 5572		return graphql.Null
 5573	}
 5574	if resTmp == nil {
 5575		if !ec.HasError(rctx) {
 5576			ec.Errorf(ctx, "must not be null")
 5577		}
 5578		return graphql.Null
 5579	}
 5580	res := resTmp.([]git.Hash)
 5581	rctx.Result = res
 5582	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5583	return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
 5584}
 5585
 5586func (ec *executionContext) _CreateTimelineItem_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5587	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5588	defer func() {
 5589		if r := recover(); r != nil {
 5590			ec.Error(ctx, ec.Recover(ctx, r))
 5591			ret = graphql.Null
 5592		}
 5593		ec.Tracer.EndFieldExecution(ctx)
 5594	}()
 5595	rctx := &graphql.ResolverContext{
 5596		Object:   "CreateTimelineItem",
 5597		Field:    field,
 5598		Args:     nil,
 5599		IsMethod: true,
 5600	}
 5601	ctx = graphql.WithResolverContext(ctx, rctx)
 5602	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5603	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5604		ctx = rctx // use context from middleware stack in children
 5605		return ec.resolvers.CreateTimelineItem().CreatedAt(rctx, obj)
 5606	})
 5607	if err != nil {
 5608		ec.Error(ctx, err)
 5609		return graphql.Null
 5610	}
 5611	if resTmp == nil {
 5612		if !ec.HasError(rctx) {
 5613			ec.Errorf(ctx, "must not be null")
 5614		}
 5615		return graphql.Null
 5616	}
 5617	res := resTmp.(*time.Time)
 5618	rctx.Result = res
 5619	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5620	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 5621}
 5622
 5623func (ec *executionContext) _CreateTimelineItem_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5624	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5625	defer func() {
 5626		if r := recover(); r != nil {
 5627			ec.Error(ctx, ec.Recover(ctx, r))
 5628			ret = graphql.Null
 5629		}
 5630		ec.Tracer.EndFieldExecution(ctx)
 5631	}()
 5632	rctx := &graphql.ResolverContext{
 5633		Object:   "CreateTimelineItem",
 5634		Field:    field,
 5635		Args:     nil,
 5636		IsMethod: true,
 5637	}
 5638	ctx = graphql.WithResolverContext(ctx, rctx)
 5639	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5640	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5641		ctx = rctx // use context from middleware stack in children
 5642		return ec.resolvers.CreateTimelineItem().LastEdit(rctx, obj)
 5643	})
 5644	if err != nil {
 5645		ec.Error(ctx, err)
 5646		return graphql.Null
 5647	}
 5648	if resTmp == nil {
 5649		if !ec.HasError(rctx) {
 5650			ec.Errorf(ctx, "must not be null")
 5651		}
 5652		return graphql.Null
 5653	}
 5654	res := resTmp.(*time.Time)
 5655	rctx.Result = res
 5656	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5657	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 5658}
 5659
 5660func (ec *executionContext) _CreateTimelineItem_edited(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5661	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5662	defer func() {
 5663		if r := recover(); r != nil {
 5664			ec.Error(ctx, ec.Recover(ctx, r))
 5665			ret = graphql.Null
 5666		}
 5667		ec.Tracer.EndFieldExecution(ctx)
 5668	}()
 5669	rctx := &graphql.ResolverContext{
 5670		Object:   "CreateTimelineItem",
 5671		Field:    field,
 5672		Args:     nil,
 5673		IsMethod: true,
 5674	}
 5675	ctx = graphql.WithResolverContext(ctx, rctx)
 5676	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5677	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5678		ctx = rctx // use context from middleware stack in children
 5679		return obj.Edited(), nil
 5680	})
 5681	if err != nil {
 5682		ec.Error(ctx, err)
 5683		return graphql.Null
 5684	}
 5685	if resTmp == nil {
 5686		if !ec.HasError(rctx) {
 5687			ec.Errorf(ctx, "must not be null")
 5688		}
 5689		return graphql.Null
 5690	}
 5691	res := resTmp.(bool)
 5692	rctx.Result = res
 5693	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5694	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 5695}
 5696
 5697func (ec *executionContext) _CreateTimelineItem_history(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) (ret graphql.Marshaler) {
 5698	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5699	defer func() {
 5700		if r := recover(); r != nil {
 5701			ec.Error(ctx, ec.Recover(ctx, r))
 5702			ret = graphql.Null
 5703		}
 5704		ec.Tracer.EndFieldExecution(ctx)
 5705	}()
 5706	rctx := &graphql.ResolverContext{
 5707		Object:   "CreateTimelineItem",
 5708		Field:    field,
 5709		Args:     nil,
 5710		IsMethod: false,
 5711	}
 5712	ctx = graphql.WithResolverContext(ctx, rctx)
 5713	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5714	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5715		ctx = rctx // use context from middleware stack in children
 5716		return obj.History, nil
 5717	})
 5718	if err != nil {
 5719		ec.Error(ctx, err)
 5720		return graphql.Null
 5721	}
 5722	if resTmp == nil {
 5723		if !ec.HasError(rctx) {
 5724			ec.Errorf(ctx, "must not be null")
 5725		}
 5726		return graphql.Null
 5727	}
 5728	res := resTmp.([]bug.CommentHistoryStep)
 5729	rctx.Result = res
 5730	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5731	return ec.marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx, field.Selections, res)
 5732}
 5733
 5734func (ec *executionContext) _EditCommentOperation_hash(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
 5735	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5736	defer func() {
 5737		if r := recover(); r != nil {
 5738			ec.Error(ctx, ec.Recover(ctx, r))
 5739			ret = graphql.Null
 5740		}
 5741		ec.Tracer.EndFieldExecution(ctx)
 5742	}()
 5743	rctx := &graphql.ResolverContext{
 5744		Object:   "EditCommentOperation",
 5745		Field:    field,
 5746		Args:     nil,
 5747		IsMethod: true,
 5748	}
 5749	ctx = graphql.WithResolverContext(ctx, rctx)
 5750	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5751	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5752		ctx = rctx // use context from middleware stack in children
 5753		return obj.Hash()
 5754	})
 5755	if err != nil {
 5756		ec.Error(ctx, err)
 5757		return graphql.Null
 5758	}
 5759	if resTmp == nil {
 5760		if !ec.HasError(rctx) {
 5761			ec.Errorf(ctx, "must not be null")
 5762		}
 5763		return graphql.Null
 5764	}
 5765	res := resTmp.(git.Hash)
 5766	rctx.Result = res
 5767	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5768	return ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
 5769}
 5770
 5771func (ec *executionContext) _EditCommentOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
 5772	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5773	defer func() {
 5774		if r := recover(); r != nil {
 5775			ec.Error(ctx, ec.Recover(ctx, r))
 5776			ret = graphql.Null
 5777		}
 5778		ec.Tracer.EndFieldExecution(ctx)
 5779	}()
 5780	rctx := &graphql.ResolverContext{
 5781		Object:   "EditCommentOperation",
 5782		Field:    field,
 5783		Args:     nil,
 5784		IsMethod: false,
 5785	}
 5786	ctx = graphql.WithResolverContext(ctx, rctx)
 5787	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5788	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5789		ctx = rctx // use context from middleware stack in children
 5790		return obj.Author, nil
 5791	})
 5792	if err != nil {
 5793		ec.Error(ctx, err)
 5794		return graphql.Null
 5795	}
 5796	if resTmp == nil {
 5797		if !ec.HasError(rctx) {
 5798			ec.Errorf(ctx, "must not be null")
 5799		}
 5800		return graphql.Null
 5801	}
 5802	res := resTmp.(identity.Interface)
 5803	rctx.Result = res
 5804	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5805	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
 5806}
 5807
 5808func (ec *executionContext) _EditCommentOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
 5809	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5810	defer func() {
 5811		if r := recover(); r != nil {
 5812			ec.Error(ctx, ec.Recover(ctx, r))
 5813			ret = graphql.Null
 5814		}
 5815		ec.Tracer.EndFieldExecution(ctx)
 5816	}()
 5817	rctx := &graphql.ResolverContext{
 5818		Object:   "EditCommentOperation",
 5819		Field:    field,
 5820		Args:     nil,
 5821		IsMethod: true,
 5822	}
 5823	ctx = graphql.WithResolverContext(ctx, rctx)
 5824	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5825	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5826		ctx = rctx // use context from middleware stack in children
 5827		return ec.resolvers.EditCommentOperation().Date(rctx, obj)
 5828	})
 5829	if err != nil {
 5830		ec.Error(ctx, err)
 5831		return graphql.Null
 5832	}
 5833	if resTmp == nil {
 5834		if !ec.HasError(rctx) {
 5835			ec.Errorf(ctx, "must not be null")
 5836		}
 5837		return graphql.Null
 5838	}
 5839	res := resTmp.(*time.Time)
 5840	rctx.Result = res
 5841	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5842	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 5843}
 5844
 5845func (ec *executionContext) _EditCommentOperation_target(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
 5846	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5847	defer func() {
 5848		if r := recover(); r != nil {
 5849			ec.Error(ctx, ec.Recover(ctx, r))
 5850			ret = graphql.Null
 5851		}
 5852		ec.Tracer.EndFieldExecution(ctx)
 5853	}()
 5854	rctx := &graphql.ResolverContext{
 5855		Object:   "EditCommentOperation",
 5856		Field:    field,
 5857		Args:     nil,
 5858		IsMethod: false,
 5859	}
 5860	ctx = graphql.WithResolverContext(ctx, rctx)
 5861	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5862	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5863		ctx = rctx // use context from middleware stack in children
 5864		return obj.Target, nil
 5865	})
 5866	if err != nil {
 5867		ec.Error(ctx, err)
 5868		return graphql.Null
 5869	}
 5870	if resTmp == nil {
 5871		if !ec.HasError(rctx) {
 5872			ec.Errorf(ctx, "must not be null")
 5873		}
 5874		return graphql.Null
 5875	}
 5876	res := resTmp.(git.Hash)
 5877	rctx.Result = res
 5878	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5879	return ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
 5880}
 5881
 5882func (ec *executionContext) _EditCommentOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
 5883	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5884	defer func() {
 5885		if r := recover(); r != nil {
 5886			ec.Error(ctx, ec.Recover(ctx, r))
 5887			ret = graphql.Null
 5888		}
 5889		ec.Tracer.EndFieldExecution(ctx)
 5890	}()
 5891	rctx := &graphql.ResolverContext{
 5892		Object:   "EditCommentOperation",
 5893		Field:    field,
 5894		Args:     nil,
 5895		IsMethod: false,
 5896	}
 5897	ctx = graphql.WithResolverContext(ctx, rctx)
 5898	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5899	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5900		ctx = rctx // use context from middleware stack in children
 5901		return obj.Message, nil
 5902	})
 5903	if err != nil {
 5904		ec.Error(ctx, err)
 5905		return graphql.Null
 5906	}
 5907	if resTmp == nil {
 5908		if !ec.HasError(rctx) {
 5909			ec.Errorf(ctx, "must not be null")
 5910		}
 5911		return graphql.Null
 5912	}
 5913	res := resTmp.(string)
 5914	rctx.Result = res
 5915	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5916	return ec.marshalNString2string(ctx, field.Selections, res)
 5917}
 5918
 5919func (ec *executionContext) _EditCommentOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) (ret graphql.Marshaler) {
 5920	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5921	defer func() {
 5922		if r := recover(); r != nil {
 5923			ec.Error(ctx, ec.Recover(ctx, r))
 5924			ret = graphql.Null
 5925		}
 5926		ec.Tracer.EndFieldExecution(ctx)
 5927	}()
 5928	rctx := &graphql.ResolverContext{
 5929		Object:   "EditCommentOperation",
 5930		Field:    field,
 5931		Args:     nil,
 5932		IsMethod: false,
 5933	}
 5934	ctx = graphql.WithResolverContext(ctx, rctx)
 5935	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5936	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5937		ctx = rctx // use context from middleware stack in children
 5938		return obj.Files, nil
 5939	})
 5940	if err != nil {
 5941		ec.Error(ctx, err)
 5942		return graphql.Null
 5943	}
 5944	if resTmp == nil {
 5945		if !ec.HasError(rctx) {
 5946			ec.Errorf(ctx, "must not be null")
 5947		}
 5948		return graphql.Null
 5949	}
 5950	res := resTmp.([]git.Hash)
 5951	rctx.Result = res
 5952	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5953	return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
 5954}
 5955
 5956func (ec *executionContext) _Identity_id(ctx context.Context, field graphql.CollectedField, obj *identity.Interface) (ret graphql.Marshaler) {
 5957	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5958	defer func() {
 5959		if r := recover(); r != nil {
 5960			ec.Error(ctx, ec.Recover(ctx, r))
 5961			ret = graphql.Null
 5962		}
 5963		ec.Tracer.EndFieldExecution(ctx)
 5964	}()
 5965	rctx := &graphql.ResolverContext{
 5966		Object:   "Identity",
 5967		Field:    field,
 5968		Args:     nil,
 5969		IsMethod: true,
 5970	}
 5971	ctx = graphql.WithResolverContext(ctx, rctx)
 5972	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5973	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 5974		ctx = rctx // use context from middleware stack in children
 5975		return ec.resolvers.Identity().ID(rctx, obj)
 5976	})
 5977	if err != nil {
 5978		ec.Error(ctx, err)
 5979		return graphql.Null
 5980	}
 5981	if resTmp == nil {
 5982		if !ec.HasError(rctx) {
 5983			ec.Errorf(ctx, "must not be null")
 5984		}
 5985		return graphql.Null
 5986	}
 5987	res := resTmp.(string)
 5988	rctx.Result = res
 5989	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5990	return ec.marshalNString2string(ctx, field.Selections, res)
 5991}
 5992
 5993func (ec *executionContext) _Identity_humanId(ctx context.Context, field graphql.CollectedField, obj *identity.Interface) (ret graphql.Marshaler) {
 5994	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5995	defer func() {
 5996		if r := recover(); r != nil {
 5997			ec.Error(ctx, ec.Recover(ctx, r))
 5998			ret = graphql.Null
 5999		}
 6000		ec.Tracer.EndFieldExecution(ctx)
 6001	}()
 6002	rctx := &graphql.ResolverContext{
 6003		Object:   "Identity",
 6004		Field:    field,
 6005		Args:     nil,
 6006		IsMethod: true,
 6007	}
 6008	ctx = graphql.WithResolverContext(ctx, rctx)
 6009	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6010	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6011		ctx = rctx // use context from middleware stack in children
 6012		return ec.resolvers.Identity().HumanID(rctx, obj)
 6013	})
 6014	if err != nil {
 6015		ec.Error(ctx, err)
 6016		return graphql.Null
 6017	}
 6018	if resTmp == nil {
 6019		if !ec.HasError(rctx) {
 6020			ec.Errorf(ctx, "must not be null")
 6021		}
 6022		return graphql.Null
 6023	}
 6024	res := resTmp.(string)
 6025	rctx.Result = res
 6026	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6027	return ec.marshalNString2string(ctx, field.Selections, res)
 6028}
 6029
 6030func (ec *executionContext) _Identity_name(ctx context.Context, field graphql.CollectedField, obj *identity.Interface) (ret graphql.Marshaler) {
 6031	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6032	defer func() {
 6033		if r := recover(); r != nil {
 6034			ec.Error(ctx, ec.Recover(ctx, r))
 6035			ret = graphql.Null
 6036		}
 6037		ec.Tracer.EndFieldExecution(ctx)
 6038	}()
 6039	rctx := &graphql.ResolverContext{
 6040		Object:   "Identity",
 6041		Field:    field,
 6042		Args:     nil,
 6043		IsMethod: true,
 6044	}
 6045	ctx = graphql.WithResolverContext(ctx, rctx)
 6046	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6047	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6048		ctx = rctx // use context from middleware stack in children
 6049		return ec.resolvers.Identity().Name(rctx, obj)
 6050	})
 6051	if err != nil {
 6052		ec.Error(ctx, err)
 6053		return graphql.Null
 6054	}
 6055	if resTmp == nil {
 6056		return graphql.Null
 6057	}
 6058	res := resTmp.(*string)
 6059	rctx.Result = res
 6060	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6061	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 6062}
 6063
 6064func (ec *executionContext) _Identity_email(ctx context.Context, field graphql.CollectedField, obj *identity.Interface) (ret graphql.Marshaler) {
 6065	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6066	defer func() {
 6067		if r := recover(); r != nil {
 6068			ec.Error(ctx, ec.Recover(ctx, r))
 6069			ret = graphql.Null
 6070		}
 6071		ec.Tracer.EndFieldExecution(ctx)
 6072	}()
 6073	rctx := &graphql.ResolverContext{
 6074		Object:   "Identity",
 6075		Field:    field,
 6076		Args:     nil,
 6077		IsMethod: true,
 6078	}
 6079	ctx = graphql.WithResolverContext(ctx, rctx)
 6080	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6081	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6082		ctx = rctx // use context from middleware stack in children
 6083		return ec.resolvers.Identity().Email(rctx, obj)
 6084	})
 6085	if err != nil {
 6086		ec.Error(ctx, err)
 6087		return graphql.Null
 6088	}
 6089	if resTmp == nil {
 6090		return graphql.Null
 6091	}
 6092	res := resTmp.(*string)
 6093	rctx.Result = res
 6094	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6095	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 6096}
 6097
 6098func (ec *executionContext) _Identity_login(ctx context.Context, field graphql.CollectedField, obj *identity.Interface) (ret graphql.Marshaler) {
 6099	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6100	defer func() {
 6101		if r := recover(); r != nil {
 6102			ec.Error(ctx, ec.Recover(ctx, r))
 6103			ret = graphql.Null
 6104		}
 6105		ec.Tracer.EndFieldExecution(ctx)
 6106	}()
 6107	rctx := &graphql.ResolverContext{
 6108		Object:   "Identity",
 6109		Field:    field,
 6110		Args:     nil,
 6111		IsMethod: true,
 6112	}
 6113	ctx = graphql.WithResolverContext(ctx, rctx)
 6114	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6115	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6116		ctx = rctx // use context from middleware stack in children
 6117		return ec.resolvers.Identity().Login(rctx, obj)
 6118	})
 6119	if err != nil {
 6120		ec.Error(ctx, err)
 6121		return graphql.Null
 6122	}
 6123	if resTmp == nil {
 6124		return graphql.Null
 6125	}
 6126	res := resTmp.(*string)
 6127	rctx.Result = res
 6128	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6129	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 6130}
 6131
 6132func (ec *executionContext) _Identity_displayName(ctx context.Context, field graphql.CollectedField, obj *identity.Interface) (ret graphql.Marshaler) {
 6133	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6134	defer func() {
 6135		if r := recover(); r != nil {
 6136			ec.Error(ctx, ec.Recover(ctx, r))
 6137			ret = graphql.Null
 6138		}
 6139		ec.Tracer.EndFieldExecution(ctx)
 6140	}()
 6141	rctx := &graphql.ResolverContext{
 6142		Object:   "Identity",
 6143		Field:    field,
 6144		Args:     nil,
 6145		IsMethod: true,
 6146	}
 6147	ctx = graphql.WithResolverContext(ctx, rctx)
 6148	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6149	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6150		ctx = rctx // use context from middleware stack in children
 6151		return ec.resolvers.Identity().DisplayName(rctx, obj)
 6152	})
 6153	if err != nil {
 6154		ec.Error(ctx, err)
 6155		return graphql.Null
 6156	}
 6157	if resTmp == nil {
 6158		if !ec.HasError(rctx) {
 6159			ec.Errorf(ctx, "must not be null")
 6160		}
 6161		return graphql.Null
 6162	}
 6163	res := resTmp.(string)
 6164	rctx.Result = res
 6165	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6166	return ec.marshalNString2string(ctx, field.Selections, res)
 6167}
 6168
 6169func (ec *executionContext) _Identity_avatarUrl(ctx context.Context, field graphql.CollectedField, obj *identity.Interface) (ret graphql.Marshaler) {
 6170	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6171	defer func() {
 6172		if r := recover(); r != nil {
 6173			ec.Error(ctx, ec.Recover(ctx, r))
 6174			ret = graphql.Null
 6175		}
 6176		ec.Tracer.EndFieldExecution(ctx)
 6177	}()
 6178	rctx := &graphql.ResolverContext{
 6179		Object:   "Identity",
 6180		Field:    field,
 6181		Args:     nil,
 6182		IsMethod: true,
 6183	}
 6184	ctx = graphql.WithResolverContext(ctx, rctx)
 6185	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6186	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6187		ctx = rctx // use context from middleware stack in children
 6188		return ec.resolvers.Identity().AvatarURL(rctx, obj)
 6189	})
 6190	if err != nil {
 6191		ec.Error(ctx, err)
 6192		return graphql.Null
 6193	}
 6194	if resTmp == nil {
 6195		return graphql.Null
 6196	}
 6197	res := resTmp.(*string)
 6198	rctx.Result = res
 6199	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6200	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 6201}
 6202
 6203func (ec *executionContext) _Identity_isProtected(ctx context.Context, field graphql.CollectedField, obj *identity.Interface) (ret graphql.Marshaler) {
 6204	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6205	defer func() {
 6206		if r := recover(); r != nil {
 6207			ec.Error(ctx, ec.Recover(ctx, r))
 6208			ret = graphql.Null
 6209		}
 6210		ec.Tracer.EndFieldExecution(ctx)
 6211	}()
 6212	rctx := &graphql.ResolverContext{
 6213		Object:   "Identity",
 6214		Field:    field,
 6215		Args:     nil,
 6216		IsMethod: true,
 6217	}
 6218	ctx = graphql.WithResolverContext(ctx, rctx)
 6219	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6220	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6221		ctx = rctx // use context from middleware stack in children
 6222		return ec.resolvers.Identity().IsProtected(rctx, obj)
 6223	})
 6224	if err != nil {
 6225		ec.Error(ctx, err)
 6226		return graphql.Null
 6227	}
 6228	if resTmp == nil {
 6229		if !ec.HasError(rctx) {
 6230			ec.Errorf(ctx, "must not be null")
 6231		}
 6232		return graphql.Null
 6233	}
 6234	res := resTmp.(bool)
 6235	rctx.Result = res
 6236	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6237	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 6238}
 6239
 6240func (ec *executionContext) _IdentityConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
 6241	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6242	defer func() {
 6243		if r := recover(); r != nil {
 6244			ec.Error(ctx, ec.Recover(ctx, r))
 6245			ret = graphql.Null
 6246		}
 6247		ec.Tracer.EndFieldExecution(ctx)
 6248	}()
 6249	rctx := &graphql.ResolverContext{
 6250		Object:   "IdentityConnection",
 6251		Field:    field,
 6252		Args:     nil,
 6253		IsMethod: false,
 6254	}
 6255	ctx = graphql.WithResolverContext(ctx, rctx)
 6256	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6257	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6258		ctx = rctx // use context from middleware stack in children
 6259		return obj.Edges, nil
 6260	})
 6261	if err != nil {
 6262		ec.Error(ctx, err)
 6263		return graphql.Null
 6264	}
 6265	if resTmp == nil {
 6266		if !ec.HasError(rctx) {
 6267			ec.Errorf(ctx, "must not be null")
 6268		}
 6269		return graphql.Null
 6270	}
 6271	res := resTmp.([]*models.IdentityEdge)
 6272	rctx.Result = res
 6273	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6274	return ec.marshalNIdentityEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx, field.Selections, res)
 6275}
 6276
 6277func (ec *executionContext) _IdentityConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
 6278	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6279	defer func() {
 6280		if r := recover(); r != nil {
 6281			ec.Error(ctx, ec.Recover(ctx, r))
 6282			ret = graphql.Null
 6283		}
 6284		ec.Tracer.EndFieldExecution(ctx)
 6285	}()
 6286	rctx := &graphql.ResolverContext{
 6287		Object:   "IdentityConnection",
 6288		Field:    field,
 6289		Args:     nil,
 6290		IsMethod: false,
 6291	}
 6292	ctx = graphql.WithResolverContext(ctx, rctx)
 6293	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6294	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6295		ctx = rctx // use context from middleware stack in children
 6296		return obj.Nodes, nil
 6297	})
 6298	if err != nil {
 6299		ec.Error(ctx, err)
 6300		return graphql.Null
 6301	}
 6302	if resTmp == nil {
 6303		if !ec.HasError(rctx) {
 6304			ec.Errorf(ctx, "must not be null")
 6305		}
 6306		return graphql.Null
 6307	}
 6308	res := resTmp.([]identity.Interface)
 6309	rctx.Result = res
 6310	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6311	return ec.marshalNIdentity2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
 6312}
 6313
 6314func (ec *executionContext) _IdentityConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
 6315	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6316	defer func() {
 6317		if r := recover(); r != nil {
 6318			ec.Error(ctx, ec.Recover(ctx, r))
 6319			ret = graphql.Null
 6320		}
 6321		ec.Tracer.EndFieldExecution(ctx)
 6322	}()
 6323	rctx := &graphql.ResolverContext{
 6324		Object:   "IdentityConnection",
 6325		Field:    field,
 6326		Args:     nil,
 6327		IsMethod: false,
 6328	}
 6329	ctx = graphql.WithResolverContext(ctx, rctx)
 6330	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6331	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6332		ctx = rctx // use context from middleware stack in children
 6333		return obj.PageInfo, nil
 6334	})
 6335	if err != nil {
 6336		ec.Error(ctx, err)
 6337		return graphql.Null
 6338	}
 6339	if resTmp == nil {
 6340		if !ec.HasError(rctx) {
 6341			ec.Errorf(ctx, "must not be null")
 6342		}
 6343		return graphql.Null
 6344	}
 6345	res := resTmp.(*models.PageInfo)
 6346	rctx.Result = res
 6347	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6348	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
 6349}
 6350
 6351func (ec *executionContext) _IdentityConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) (ret graphql.Marshaler) {
 6352	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6353	defer func() {
 6354		if r := recover(); r != nil {
 6355			ec.Error(ctx, ec.Recover(ctx, r))
 6356			ret = graphql.Null
 6357		}
 6358		ec.Tracer.EndFieldExecution(ctx)
 6359	}()
 6360	rctx := &graphql.ResolverContext{
 6361		Object:   "IdentityConnection",
 6362		Field:    field,
 6363		Args:     nil,
 6364		IsMethod: false,
 6365	}
 6366	ctx = graphql.WithResolverContext(ctx, rctx)
 6367	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6368	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6369		ctx = rctx // use context from middleware stack in children
 6370		return obj.TotalCount, nil
 6371	})
 6372	if err != nil {
 6373		ec.Error(ctx, err)
 6374		return graphql.Null
 6375	}
 6376	if resTmp == nil {
 6377		if !ec.HasError(rctx) {
 6378			ec.Errorf(ctx, "must not be null")
 6379		}
 6380		return graphql.Null
 6381	}
 6382	res := resTmp.(int)
 6383	rctx.Result = res
 6384	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6385	return ec.marshalNInt2int(ctx, field.Selections, res)
 6386}
 6387
 6388func (ec *executionContext) _IdentityEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.IdentityEdge) (ret graphql.Marshaler) {
 6389	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6390	defer func() {
 6391		if r := recover(); r != nil {
 6392			ec.Error(ctx, ec.Recover(ctx, r))
 6393			ret = graphql.Null
 6394		}
 6395		ec.Tracer.EndFieldExecution(ctx)
 6396	}()
 6397	rctx := &graphql.ResolverContext{
 6398		Object:   "IdentityEdge",
 6399		Field:    field,
 6400		Args:     nil,
 6401		IsMethod: false,
 6402	}
 6403	ctx = graphql.WithResolverContext(ctx, rctx)
 6404	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6405	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6406		ctx = rctx // use context from middleware stack in children
 6407		return obj.Cursor, nil
 6408	})
 6409	if err != nil {
 6410		ec.Error(ctx, err)
 6411		return graphql.Null
 6412	}
 6413	if resTmp == nil {
 6414		if !ec.HasError(rctx) {
 6415			ec.Errorf(ctx, "must not be null")
 6416		}
 6417		return graphql.Null
 6418	}
 6419	res := resTmp.(string)
 6420	rctx.Result = res
 6421	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6422	return ec.marshalNString2string(ctx, field.Selections, res)
 6423}
 6424
 6425func (ec *executionContext) _IdentityEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.IdentityEdge) (ret graphql.Marshaler) {
 6426	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6427	defer func() {
 6428		if r := recover(); r != nil {
 6429			ec.Error(ctx, ec.Recover(ctx, r))
 6430			ret = graphql.Null
 6431		}
 6432		ec.Tracer.EndFieldExecution(ctx)
 6433	}()
 6434	rctx := &graphql.ResolverContext{
 6435		Object:   "IdentityEdge",
 6436		Field:    field,
 6437		Args:     nil,
 6438		IsMethod: false,
 6439	}
 6440	ctx = graphql.WithResolverContext(ctx, rctx)
 6441	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6442	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6443		ctx = rctx // use context from middleware stack in children
 6444		return obj.Node, nil
 6445	})
 6446	if err != nil {
 6447		ec.Error(ctx, err)
 6448		return graphql.Null
 6449	}
 6450	if resTmp == nil {
 6451		if !ec.HasError(rctx) {
 6452			ec.Errorf(ctx, "must not be null")
 6453		}
 6454		return graphql.Null
 6455	}
 6456	res := resTmp.(identity.Interface)
 6457	rctx.Result = res
 6458	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6459	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
 6460}
 6461
 6462func (ec *executionContext) _Label_name(ctx context.Context, field graphql.CollectedField, obj *bug.Label) (ret graphql.Marshaler) {
 6463	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6464	defer func() {
 6465		if r := recover(); r != nil {
 6466			ec.Error(ctx, ec.Recover(ctx, r))
 6467			ret = graphql.Null
 6468		}
 6469		ec.Tracer.EndFieldExecution(ctx)
 6470	}()
 6471	rctx := &graphql.ResolverContext{
 6472		Object:   "Label",
 6473		Field:    field,
 6474		Args:     nil,
 6475		IsMethod: true,
 6476	}
 6477	ctx = graphql.WithResolverContext(ctx, rctx)
 6478	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6479	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6480		ctx = rctx // use context from middleware stack in children
 6481		return ec.resolvers.Label().Name(rctx, obj)
 6482	})
 6483	if err != nil {
 6484		ec.Error(ctx, err)
 6485		return graphql.Null
 6486	}
 6487	if resTmp == nil {
 6488		if !ec.HasError(rctx) {
 6489			ec.Errorf(ctx, "must not be null")
 6490		}
 6491		return graphql.Null
 6492	}
 6493	res := resTmp.(string)
 6494	rctx.Result = res
 6495	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6496	return ec.marshalNString2string(ctx, field.Selections, res)
 6497}
 6498
 6499func (ec *executionContext) _Label_color(ctx context.Context, field graphql.CollectedField, obj *bug.Label) (ret graphql.Marshaler) {
 6500	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6501	defer func() {
 6502		if r := recover(); r != nil {
 6503			ec.Error(ctx, ec.Recover(ctx, r))
 6504			ret = graphql.Null
 6505		}
 6506		ec.Tracer.EndFieldExecution(ctx)
 6507	}()
 6508	rctx := &graphql.ResolverContext{
 6509		Object:   "Label",
 6510		Field:    field,
 6511		Args:     nil,
 6512		IsMethod: true,
 6513	}
 6514	ctx = graphql.WithResolverContext(ctx, rctx)
 6515	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6516	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6517		ctx = rctx // use context from middleware stack in children
 6518		return ec.resolvers.Label().Color(rctx, obj)
 6519	})
 6520	if err != nil {
 6521		ec.Error(ctx, err)
 6522		return graphql.Null
 6523	}
 6524	if resTmp == nil {
 6525		if !ec.HasError(rctx) {
 6526			ec.Errorf(ctx, "must not be null")
 6527		}
 6528		return graphql.Null
 6529	}
 6530	res := resTmp.(*color.RGBA)
 6531	rctx.Result = res
 6532	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6533	return ec.marshalNColor2ᚖimageᚋcolorᚐRGBA(ctx, field.Selections, res)
 6534}
 6535
 6536func (ec *executionContext) _LabelChangeOperation_hash(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
 6537	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6538	defer func() {
 6539		if r := recover(); r != nil {
 6540			ec.Error(ctx, ec.Recover(ctx, r))
 6541			ret = graphql.Null
 6542		}
 6543		ec.Tracer.EndFieldExecution(ctx)
 6544	}()
 6545	rctx := &graphql.ResolverContext{
 6546		Object:   "LabelChangeOperation",
 6547		Field:    field,
 6548		Args:     nil,
 6549		IsMethod: true,
 6550	}
 6551	ctx = graphql.WithResolverContext(ctx, rctx)
 6552	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6553	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6554		ctx = rctx // use context from middleware stack in children
 6555		return obj.Hash()
 6556	})
 6557	if err != nil {
 6558		ec.Error(ctx, err)
 6559		return graphql.Null
 6560	}
 6561	if resTmp == nil {
 6562		if !ec.HasError(rctx) {
 6563			ec.Errorf(ctx, "must not be null")
 6564		}
 6565		return graphql.Null
 6566	}
 6567	res := resTmp.(git.Hash)
 6568	rctx.Result = res
 6569	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6570	return ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
 6571}
 6572
 6573func (ec *executionContext) _LabelChangeOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
 6574	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6575	defer func() {
 6576		if r := recover(); r != nil {
 6577			ec.Error(ctx, ec.Recover(ctx, r))
 6578			ret = graphql.Null
 6579		}
 6580		ec.Tracer.EndFieldExecution(ctx)
 6581	}()
 6582	rctx := &graphql.ResolverContext{
 6583		Object:   "LabelChangeOperation",
 6584		Field:    field,
 6585		Args:     nil,
 6586		IsMethod: false,
 6587	}
 6588	ctx = graphql.WithResolverContext(ctx, rctx)
 6589	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6590	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6591		ctx = rctx // use context from middleware stack in children
 6592		return obj.Author, nil
 6593	})
 6594	if err != nil {
 6595		ec.Error(ctx, err)
 6596		return graphql.Null
 6597	}
 6598	if resTmp == nil {
 6599		if !ec.HasError(rctx) {
 6600			ec.Errorf(ctx, "must not be null")
 6601		}
 6602		return graphql.Null
 6603	}
 6604	res := resTmp.(identity.Interface)
 6605	rctx.Result = res
 6606	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6607	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
 6608}
 6609
 6610func (ec *executionContext) _LabelChangeOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
 6611	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6612	defer func() {
 6613		if r := recover(); r != nil {
 6614			ec.Error(ctx, ec.Recover(ctx, r))
 6615			ret = graphql.Null
 6616		}
 6617		ec.Tracer.EndFieldExecution(ctx)
 6618	}()
 6619	rctx := &graphql.ResolverContext{
 6620		Object:   "LabelChangeOperation",
 6621		Field:    field,
 6622		Args:     nil,
 6623		IsMethod: true,
 6624	}
 6625	ctx = graphql.WithResolverContext(ctx, rctx)
 6626	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6627	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6628		ctx = rctx // use context from middleware stack in children
 6629		return ec.resolvers.LabelChangeOperation().Date(rctx, obj)
 6630	})
 6631	if err != nil {
 6632		ec.Error(ctx, err)
 6633		return graphql.Null
 6634	}
 6635	if resTmp == nil {
 6636		if !ec.HasError(rctx) {
 6637			ec.Errorf(ctx, "must not be null")
 6638		}
 6639		return graphql.Null
 6640	}
 6641	res := resTmp.(*time.Time)
 6642	rctx.Result = res
 6643	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6644	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 6645}
 6646
 6647func (ec *executionContext) _LabelChangeOperation_added(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
 6648	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6649	defer func() {
 6650		if r := recover(); r != nil {
 6651			ec.Error(ctx, ec.Recover(ctx, r))
 6652			ret = graphql.Null
 6653		}
 6654		ec.Tracer.EndFieldExecution(ctx)
 6655	}()
 6656	rctx := &graphql.ResolverContext{
 6657		Object:   "LabelChangeOperation",
 6658		Field:    field,
 6659		Args:     nil,
 6660		IsMethod: false,
 6661	}
 6662	ctx = graphql.WithResolverContext(ctx, rctx)
 6663	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6664	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6665		ctx = rctx // use context from middleware stack in children
 6666		return obj.Added, nil
 6667	})
 6668	if err != nil {
 6669		ec.Error(ctx, err)
 6670		return graphql.Null
 6671	}
 6672	if resTmp == nil {
 6673		if !ec.HasError(rctx) {
 6674			ec.Errorf(ctx, "must not be null")
 6675		}
 6676		return graphql.Null
 6677	}
 6678	res := resTmp.([]bug.Label)
 6679	rctx.Result = res
 6680	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6681	return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
 6682}
 6683
 6684func (ec *executionContext) _LabelChangeOperation_removed(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) (ret graphql.Marshaler) {
 6685	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6686	defer func() {
 6687		if r := recover(); r != nil {
 6688			ec.Error(ctx, ec.Recover(ctx, r))
 6689			ret = graphql.Null
 6690		}
 6691		ec.Tracer.EndFieldExecution(ctx)
 6692	}()
 6693	rctx := &graphql.ResolverContext{
 6694		Object:   "LabelChangeOperation",
 6695		Field:    field,
 6696		Args:     nil,
 6697		IsMethod: false,
 6698	}
 6699	ctx = graphql.WithResolverContext(ctx, rctx)
 6700	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6701	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6702		ctx = rctx // use context from middleware stack in children
 6703		return obj.Removed, nil
 6704	})
 6705	if err != nil {
 6706		ec.Error(ctx, err)
 6707		return graphql.Null
 6708	}
 6709	if resTmp == nil {
 6710		if !ec.HasError(rctx) {
 6711			ec.Errorf(ctx, "must not be null")
 6712		}
 6713		return graphql.Null
 6714	}
 6715	res := resTmp.([]bug.Label)
 6716	rctx.Result = res
 6717	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6718	return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
 6719}
 6720
 6721func (ec *executionContext) _LabelChangeResult_label(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeResult) (ret graphql.Marshaler) {
 6722	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6723	defer func() {
 6724		if r := recover(); r != nil {
 6725			ec.Error(ctx, ec.Recover(ctx, r))
 6726			ret = graphql.Null
 6727		}
 6728		ec.Tracer.EndFieldExecution(ctx)
 6729	}()
 6730	rctx := &graphql.ResolverContext{
 6731		Object:   "LabelChangeResult",
 6732		Field:    field,
 6733		Args:     nil,
 6734		IsMethod: false,
 6735	}
 6736	ctx = graphql.WithResolverContext(ctx, rctx)
 6737	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6738	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6739		ctx = rctx // use context from middleware stack in children
 6740		return obj.Label, nil
 6741	})
 6742	if err != nil {
 6743		ec.Error(ctx, err)
 6744		return graphql.Null
 6745	}
 6746	if resTmp == nil {
 6747		if !ec.HasError(rctx) {
 6748			ec.Errorf(ctx, "must not be null")
 6749		}
 6750		return graphql.Null
 6751	}
 6752	res := resTmp.(bug.Label)
 6753	rctx.Result = res
 6754	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6755	return ec.marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
 6756}
 6757
 6758func (ec *executionContext) _LabelChangeResult_status(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeResult) (ret graphql.Marshaler) {
 6759	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6760	defer func() {
 6761		if r := recover(); r != nil {
 6762			ec.Error(ctx, ec.Recover(ctx, r))
 6763			ret = graphql.Null
 6764		}
 6765		ec.Tracer.EndFieldExecution(ctx)
 6766	}()
 6767	rctx := &graphql.ResolverContext{
 6768		Object:   "LabelChangeResult",
 6769		Field:    field,
 6770		Args:     nil,
 6771		IsMethod: true,
 6772	}
 6773	ctx = graphql.WithResolverContext(ctx, rctx)
 6774	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6775	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6776		ctx = rctx // use context from middleware stack in children
 6777		return ec.resolvers.LabelChangeResult().Status(rctx, obj)
 6778	})
 6779	if err != nil {
 6780		ec.Error(ctx, err)
 6781		return graphql.Null
 6782	}
 6783	if resTmp == nil {
 6784		if !ec.HasError(rctx) {
 6785			ec.Errorf(ctx, "must not be null")
 6786		}
 6787		return graphql.Null
 6788	}
 6789	res := resTmp.(models.LabelChangeStatus)
 6790	rctx.Result = res
 6791	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6792	return ec.marshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx, field.Selections, res)
 6793}
 6794
 6795func (ec *executionContext) _LabelChangeTimelineItem_hash(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
 6796	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6797	defer func() {
 6798		if r := recover(); r != nil {
 6799			ec.Error(ctx, ec.Recover(ctx, r))
 6800			ret = graphql.Null
 6801		}
 6802		ec.Tracer.EndFieldExecution(ctx)
 6803	}()
 6804	rctx := &graphql.ResolverContext{
 6805		Object:   "LabelChangeTimelineItem",
 6806		Field:    field,
 6807		Args:     nil,
 6808		IsMethod: true,
 6809	}
 6810	ctx = graphql.WithResolverContext(ctx, rctx)
 6811	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6812	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6813		ctx = rctx // use context from middleware stack in children
 6814		return obj.Hash(), nil
 6815	})
 6816	if err != nil {
 6817		ec.Error(ctx, err)
 6818		return graphql.Null
 6819	}
 6820	if resTmp == nil {
 6821		if !ec.HasError(rctx) {
 6822			ec.Errorf(ctx, "must not be null")
 6823		}
 6824		return graphql.Null
 6825	}
 6826	res := resTmp.(git.Hash)
 6827	rctx.Result = res
 6828	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6829	return ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
 6830}
 6831
 6832func (ec *executionContext) _LabelChangeTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
 6833	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6834	defer func() {
 6835		if r := recover(); r != nil {
 6836			ec.Error(ctx, ec.Recover(ctx, r))
 6837			ret = graphql.Null
 6838		}
 6839		ec.Tracer.EndFieldExecution(ctx)
 6840	}()
 6841	rctx := &graphql.ResolverContext{
 6842		Object:   "LabelChangeTimelineItem",
 6843		Field:    field,
 6844		Args:     nil,
 6845		IsMethod: false,
 6846	}
 6847	ctx = graphql.WithResolverContext(ctx, rctx)
 6848	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6849	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6850		ctx = rctx // use context from middleware stack in children
 6851		return obj.Author, nil
 6852	})
 6853	if err != nil {
 6854		ec.Error(ctx, err)
 6855		return graphql.Null
 6856	}
 6857	if resTmp == nil {
 6858		if !ec.HasError(rctx) {
 6859			ec.Errorf(ctx, "must not be null")
 6860		}
 6861		return graphql.Null
 6862	}
 6863	res := resTmp.(identity.Interface)
 6864	rctx.Result = res
 6865	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6866	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
 6867}
 6868
 6869func (ec *executionContext) _LabelChangeTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
 6870	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6871	defer func() {
 6872		if r := recover(); r != nil {
 6873			ec.Error(ctx, ec.Recover(ctx, r))
 6874			ret = graphql.Null
 6875		}
 6876		ec.Tracer.EndFieldExecution(ctx)
 6877	}()
 6878	rctx := &graphql.ResolverContext{
 6879		Object:   "LabelChangeTimelineItem",
 6880		Field:    field,
 6881		Args:     nil,
 6882		IsMethod: true,
 6883	}
 6884	ctx = graphql.WithResolverContext(ctx, rctx)
 6885	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6886	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6887		ctx = rctx // use context from middleware stack in children
 6888		return ec.resolvers.LabelChangeTimelineItem().Date(rctx, obj)
 6889	})
 6890	if err != nil {
 6891		ec.Error(ctx, err)
 6892		return graphql.Null
 6893	}
 6894	if resTmp == nil {
 6895		if !ec.HasError(rctx) {
 6896			ec.Errorf(ctx, "must not be null")
 6897		}
 6898		return graphql.Null
 6899	}
 6900	res := resTmp.(*time.Time)
 6901	rctx.Result = res
 6902	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6903	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 6904}
 6905
 6906func (ec *executionContext) _LabelChangeTimelineItem_added(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
 6907	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6908	defer func() {
 6909		if r := recover(); r != nil {
 6910			ec.Error(ctx, ec.Recover(ctx, r))
 6911			ret = graphql.Null
 6912		}
 6913		ec.Tracer.EndFieldExecution(ctx)
 6914	}()
 6915	rctx := &graphql.ResolverContext{
 6916		Object:   "LabelChangeTimelineItem",
 6917		Field:    field,
 6918		Args:     nil,
 6919		IsMethod: false,
 6920	}
 6921	ctx = graphql.WithResolverContext(ctx, rctx)
 6922	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6923	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6924		ctx = rctx // use context from middleware stack in children
 6925		return obj.Added, nil
 6926	})
 6927	if err != nil {
 6928		ec.Error(ctx, err)
 6929		return graphql.Null
 6930	}
 6931	if resTmp == nil {
 6932		if !ec.HasError(rctx) {
 6933			ec.Errorf(ctx, "must not be null")
 6934		}
 6935		return graphql.Null
 6936	}
 6937	res := resTmp.([]bug.Label)
 6938	rctx.Result = res
 6939	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6940	return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
 6941}
 6942
 6943func (ec *executionContext) _LabelChangeTimelineItem_removed(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) (ret graphql.Marshaler) {
 6944	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6945	defer func() {
 6946		if r := recover(); r != nil {
 6947			ec.Error(ctx, ec.Recover(ctx, r))
 6948			ret = graphql.Null
 6949		}
 6950		ec.Tracer.EndFieldExecution(ctx)
 6951	}()
 6952	rctx := &graphql.ResolverContext{
 6953		Object:   "LabelChangeTimelineItem",
 6954		Field:    field,
 6955		Args:     nil,
 6956		IsMethod: false,
 6957	}
 6958	ctx = graphql.WithResolverContext(ctx, rctx)
 6959	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6960	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 6961		ctx = rctx // use context from middleware stack in children
 6962		return obj.Removed, nil
 6963	})
 6964	if err != nil {
 6965		ec.Error(ctx, err)
 6966		return graphql.Null
 6967	}
 6968	if resTmp == nil {
 6969		if !ec.HasError(rctx) {
 6970			ec.Errorf(ctx, "must not be null")
 6971		}
 6972		return graphql.Null
 6973	}
 6974	res := resTmp.([]bug.Label)
 6975	rctx.Result = res
 6976	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6977	return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
 6978}
 6979
 6980func (ec *executionContext) _Mutation_newBug(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 6981	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6982	defer func() {
 6983		if r := recover(); r != nil {
 6984			ec.Error(ctx, ec.Recover(ctx, r))
 6985			ret = graphql.Null
 6986		}
 6987		ec.Tracer.EndFieldExecution(ctx)
 6988	}()
 6989	rctx := &graphql.ResolverContext{
 6990		Object:   "Mutation",
 6991		Field:    field,
 6992		Args:     nil,
 6993		IsMethod: true,
 6994	}
 6995	ctx = graphql.WithResolverContext(ctx, rctx)
 6996	rawArgs := field.ArgumentMap(ec.Variables)
 6997	args, err := ec.field_Mutation_newBug_args(ctx, rawArgs)
 6998	if err != nil {
 6999		ec.Error(ctx, err)
 7000		return graphql.Null
 7001	}
 7002	rctx.Args = args
 7003	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7004	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7005		ctx = rctx // use context from middleware stack in children
 7006		return ec.resolvers.Mutation().NewBug(rctx, args["input"].(models.NewBugInput))
 7007	})
 7008	if err != nil {
 7009		ec.Error(ctx, err)
 7010		return graphql.Null
 7011	}
 7012	if resTmp == nil {
 7013		if !ec.HasError(rctx) {
 7014			ec.Errorf(ctx, "must not be null")
 7015		}
 7016		return graphql.Null
 7017	}
 7018	res := resTmp.(*models.NewBugPayload)
 7019	rctx.Result = res
 7020	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7021	return ec.marshalNNewBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugPayload(ctx, field.Selections, res)
 7022}
 7023
 7024func (ec *executionContext) _Mutation_addComment(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 7025	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7026	defer func() {
 7027		if r := recover(); r != nil {
 7028			ec.Error(ctx, ec.Recover(ctx, r))
 7029			ret = graphql.Null
 7030		}
 7031		ec.Tracer.EndFieldExecution(ctx)
 7032	}()
 7033	rctx := &graphql.ResolverContext{
 7034		Object:   "Mutation",
 7035		Field:    field,
 7036		Args:     nil,
 7037		IsMethod: true,
 7038	}
 7039	ctx = graphql.WithResolverContext(ctx, rctx)
 7040	rawArgs := field.ArgumentMap(ec.Variables)
 7041	args, err := ec.field_Mutation_addComment_args(ctx, rawArgs)
 7042	if err != nil {
 7043		ec.Error(ctx, err)
 7044		return graphql.Null
 7045	}
 7046	rctx.Args = args
 7047	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7048	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7049		ctx = rctx // use context from middleware stack in children
 7050		return ec.resolvers.Mutation().AddComment(rctx, args["input"].(models.AddCommentInput))
 7051	})
 7052	if err != nil {
 7053		ec.Error(ctx, err)
 7054		return graphql.Null
 7055	}
 7056	if resTmp == nil {
 7057		if !ec.HasError(rctx) {
 7058			ec.Errorf(ctx, "must not be null")
 7059		}
 7060		return graphql.Null
 7061	}
 7062	res := resTmp.(*models.AddCommentPayload)
 7063	rctx.Result = res
 7064	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7065	return ec.marshalNAddCommentPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx, field.Selections, res)
 7066}
 7067
 7068func (ec *executionContext) _Mutation_changeLabels(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 7069	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7070	defer func() {
 7071		if r := recover(); r != nil {
 7072			ec.Error(ctx, ec.Recover(ctx, r))
 7073			ret = graphql.Null
 7074		}
 7075		ec.Tracer.EndFieldExecution(ctx)
 7076	}()
 7077	rctx := &graphql.ResolverContext{
 7078		Object:   "Mutation",
 7079		Field:    field,
 7080		Args:     nil,
 7081		IsMethod: true,
 7082	}
 7083	ctx = graphql.WithResolverContext(ctx, rctx)
 7084	rawArgs := field.ArgumentMap(ec.Variables)
 7085	args, err := ec.field_Mutation_changeLabels_args(ctx, rawArgs)
 7086	if err != nil {
 7087		ec.Error(ctx, err)
 7088		return graphql.Null
 7089	}
 7090	rctx.Args = args
 7091	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7092	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7093		ctx = rctx // use context from middleware stack in children
 7094		return ec.resolvers.Mutation().ChangeLabels(rctx, args["input"].(*models.ChangeLabelInput))
 7095	})
 7096	if err != nil {
 7097		ec.Error(ctx, err)
 7098		return graphql.Null
 7099	}
 7100	if resTmp == nil {
 7101		if !ec.HasError(rctx) {
 7102			ec.Errorf(ctx, "must not be null")
 7103		}
 7104		return graphql.Null
 7105	}
 7106	res := resTmp.(*models.ChangeLabelPayload)
 7107	rctx.Result = res
 7108	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7109	return ec.marshalNChangeLabelPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx, field.Selections, res)
 7110}
 7111
 7112func (ec *executionContext) _Mutation_openBug(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 7113	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7114	defer func() {
 7115		if r := recover(); r != nil {
 7116			ec.Error(ctx, ec.Recover(ctx, r))
 7117			ret = graphql.Null
 7118		}
 7119		ec.Tracer.EndFieldExecution(ctx)
 7120	}()
 7121	rctx := &graphql.ResolverContext{
 7122		Object:   "Mutation",
 7123		Field:    field,
 7124		Args:     nil,
 7125		IsMethod: true,
 7126	}
 7127	ctx = graphql.WithResolverContext(ctx, rctx)
 7128	rawArgs := field.ArgumentMap(ec.Variables)
 7129	args, err := ec.field_Mutation_openBug_args(ctx, rawArgs)
 7130	if err != nil {
 7131		ec.Error(ctx, err)
 7132		return graphql.Null
 7133	}
 7134	rctx.Args = args
 7135	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7136	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7137		ctx = rctx // use context from middleware stack in children
 7138		return ec.resolvers.Mutation().OpenBug(rctx, args["input"].(models.OpenBugInput))
 7139	})
 7140	if err != nil {
 7141		ec.Error(ctx, err)
 7142		return graphql.Null
 7143	}
 7144	if resTmp == nil {
 7145		if !ec.HasError(rctx) {
 7146			ec.Errorf(ctx, "must not be null")
 7147		}
 7148		return graphql.Null
 7149	}
 7150	res := resTmp.(*models.OpenBugPayload)
 7151	rctx.Result = res
 7152	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7153	return ec.marshalNOpenBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx, field.Selections, res)
 7154}
 7155
 7156func (ec *executionContext) _Mutation_closeBug(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 7157	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7158	defer func() {
 7159		if r := recover(); r != nil {
 7160			ec.Error(ctx, ec.Recover(ctx, r))
 7161			ret = graphql.Null
 7162		}
 7163		ec.Tracer.EndFieldExecution(ctx)
 7164	}()
 7165	rctx := &graphql.ResolverContext{
 7166		Object:   "Mutation",
 7167		Field:    field,
 7168		Args:     nil,
 7169		IsMethod: true,
 7170	}
 7171	ctx = graphql.WithResolverContext(ctx, rctx)
 7172	rawArgs := field.ArgumentMap(ec.Variables)
 7173	args, err := ec.field_Mutation_closeBug_args(ctx, rawArgs)
 7174	if err != nil {
 7175		ec.Error(ctx, err)
 7176		return graphql.Null
 7177	}
 7178	rctx.Args = args
 7179	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7180	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7181		ctx = rctx // use context from middleware stack in children
 7182		return ec.resolvers.Mutation().CloseBug(rctx, args["input"].(models.CloseBugInput))
 7183	})
 7184	if err != nil {
 7185		ec.Error(ctx, err)
 7186		return graphql.Null
 7187	}
 7188	if resTmp == nil {
 7189		if !ec.HasError(rctx) {
 7190			ec.Errorf(ctx, "must not be null")
 7191		}
 7192		return graphql.Null
 7193	}
 7194	res := resTmp.(*models.CloseBugPayload)
 7195	rctx.Result = res
 7196	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7197	return ec.marshalNCloseBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx, field.Selections, res)
 7198}
 7199
 7200func (ec *executionContext) _Mutation_setTitle(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 7201	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7202	defer func() {
 7203		if r := recover(); r != nil {
 7204			ec.Error(ctx, ec.Recover(ctx, r))
 7205			ret = graphql.Null
 7206		}
 7207		ec.Tracer.EndFieldExecution(ctx)
 7208	}()
 7209	rctx := &graphql.ResolverContext{
 7210		Object:   "Mutation",
 7211		Field:    field,
 7212		Args:     nil,
 7213		IsMethod: true,
 7214	}
 7215	ctx = graphql.WithResolverContext(ctx, rctx)
 7216	rawArgs := field.ArgumentMap(ec.Variables)
 7217	args, err := ec.field_Mutation_setTitle_args(ctx, rawArgs)
 7218	if err != nil {
 7219		ec.Error(ctx, err)
 7220		return graphql.Null
 7221	}
 7222	rctx.Args = args
 7223	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7224	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7225		ctx = rctx // use context from middleware stack in children
 7226		return ec.resolvers.Mutation().SetTitle(rctx, args["input"].(models.SetTitleInput))
 7227	})
 7228	if err != nil {
 7229		ec.Error(ctx, err)
 7230		return graphql.Null
 7231	}
 7232	if resTmp == nil {
 7233		if !ec.HasError(rctx) {
 7234			ec.Errorf(ctx, "must not be null")
 7235		}
 7236		return graphql.Null
 7237	}
 7238	res := resTmp.(*models.SetTitlePayload)
 7239	rctx.Result = res
 7240	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7241	return ec.marshalNSetTitlePayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx, field.Selections, res)
 7242}
 7243
 7244func (ec *executionContext) _Mutation_commit(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 7245	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7246	defer func() {
 7247		if r := recover(); r != nil {
 7248			ec.Error(ctx, ec.Recover(ctx, r))
 7249			ret = graphql.Null
 7250		}
 7251		ec.Tracer.EndFieldExecution(ctx)
 7252	}()
 7253	rctx := &graphql.ResolverContext{
 7254		Object:   "Mutation",
 7255		Field:    field,
 7256		Args:     nil,
 7257		IsMethod: true,
 7258	}
 7259	ctx = graphql.WithResolverContext(ctx, rctx)
 7260	rawArgs := field.ArgumentMap(ec.Variables)
 7261	args, err := ec.field_Mutation_commit_args(ctx, rawArgs)
 7262	if err != nil {
 7263		ec.Error(ctx, err)
 7264		return graphql.Null
 7265	}
 7266	rctx.Args = args
 7267	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7268	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7269		ctx = rctx // use context from middleware stack in children
 7270		return ec.resolvers.Mutation().Commit(rctx, args["input"].(models.CommitInput))
 7271	})
 7272	if err != nil {
 7273		ec.Error(ctx, err)
 7274		return graphql.Null
 7275	}
 7276	if resTmp == nil {
 7277		if !ec.HasError(rctx) {
 7278			ec.Errorf(ctx, "must not be null")
 7279		}
 7280		return graphql.Null
 7281	}
 7282	res := resTmp.(*models.CommitPayload)
 7283	rctx.Result = res
 7284	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7285	return ec.marshalNCommitPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitPayload(ctx, field.Selections, res)
 7286}
 7287
 7288func (ec *executionContext) _Mutation_commitAsNeeded(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 7289	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7290	defer func() {
 7291		if r := recover(); r != nil {
 7292			ec.Error(ctx, ec.Recover(ctx, r))
 7293			ret = graphql.Null
 7294		}
 7295		ec.Tracer.EndFieldExecution(ctx)
 7296	}()
 7297	rctx := &graphql.ResolverContext{
 7298		Object:   "Mutation",
 7299		Field:    field,
 7300		Args:     nil,
 7301		IsMethod: true,
 7302	}
 7303	ctx = graphql.WithResolverContext(ctx, rctx)
 7304	rawArgs := field.ArgumentMap(ec.Variables)
 7305	args, err := ec.field_Mutation_commitAsNeeded_args(ctx, rawArgs)
 7306	if err != nil {
 7307		ec.Error(ctx, err)
 7308		return graphql.Null
 7309	}
 7310	rctx.Args = args
 7311	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7312	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7313		ctx = rctx // use context from middleware stack in children
 7314		return ec.resolvers.Mutation().CommitAsNeeded(rctx, args["input"].(models.CommitAsNeededInput))
 7315	})
 7316	if err != nil {
 7317		ec.Error(ctx, err)
 7318		return graphql.Null
 7319	}
 7320	if resTmp == nil {
 7321		if !ec.HasError(rctx) {
 7322			ec.Errorf(ctx, "must not be null")
 7323		}
 7324		return graphql.Null
 7325	}
 7326	res := resTmp.(*models.CommitAsNeededPayload)
 7327	rctx.Result = res
 7328	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7329	return ec.marshalNCommitAsNeededPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitAsNeededPayload(ctx, field.Selections, res)
 7330}
 7331
 7332func (ec *executionContext) _NewBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) (ret graphql.Marshaler) {
 7333	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7334	defer func() {
 7335		if r := recover(); r != nil {
 7336			ec.Error(ctx, ec.Recover(ctx, r))
 7337			ret = graphql.Null
 7338		}
 7339		ec.Tracer.EndFieldExecution(ctx)
 7340	}()
 7341	rctx := &graphql.ResolverContext{
 7342		Object:   "NewBugPayload",
 7343		Field:    field,
 7344		Args:     nil,
 7345		IsMethod: false,
 7346	}
 7347	ctx = graphql.WithResolverContext(ctx, rctx)
 7348	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7349	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7350		ctx = rctx // use context from middleware stack in children
 7351		return obj.ClientMutationID, nil
 7352	})
 7353	if err != nil {
 7354		ec.Error(ctx, err)
 7355		return graphql.Null
 7356	}
 7357	if resTmp == nil {
 7358		return graphql.Null
 7359	}
 7360	res := resTmp.(*string)
 7361	rctx.Result = res
 7362	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7363	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 7364}
 7365
 7366func (ec *executionContext) _NewBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) (ret graphql.Marshaler) {
 7367	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7368	defer func() {
 7369		if r := recover(); r != nil {
 7370			ec.Error(ctx, ec.Recover(ctx, r))
 7371			ret = graphql.Null
 7372		}
 7373		ec.Tracer.EndFieldExecution(ctx)
 7374	}()
 7375	rctx := &graphql.ResolverContext{
 7376		Object:   "NewBugPayload",
 7377		Field:    field,
 7378		Args:     nil,
 7379		IsMethod: false,
 7380	}
 7381	ctx = graphql.WithResolverContext(ctx, rctx)
 7382	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7383	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7384		ctx = rctx // use context from middleware stack in children
 7385		return obj.Bug, nil
 7386	})
 7387	if err != nil {
 7388		ec.Error(ctx, err)
 7389		return graphql.Null
 7390	}
 7391	if resTmp == nil {
 7392		if !ec.HasError(rctx) {
 7393			ec.Errorf(ctx, "must not be null")
 7394		}
 7395		return graphql.Null
 7396	}
 7397	res := resTmp.(*bug.Snapshot)
 7398	rctx.Result = res
 7399	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7400	return ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
 7401}
 7402
 7403func (ec *executionContext) _NewBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) (ret graphql.Marshaler) {
 7404	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7405	defer func() {
 7406		if r := recover(); r != nil {
 7407			ec.Error(ctx, ec.Recover(ctx, r))
 7408			ret = graphql.Null
 7409		}
 7410		ec.Tracer.EndFieldExecution(ctx)
 7411	}()
 7412	rctx := &graphql.ResolverContext{
 7413		Object:   "NewBugPayload",
 7414		Field:    field,
 7415		Args:     nil,
 7416		IsMethod: false,
 7417	}
 7418	ctx = graphql.WithResolverContext(ctx, rctx)
 7419	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7420	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7421		ctx = rctx // use context from middleware stack in children
 7422		return obj.Operation, nil
 7423	})
 7424	if err != nil {
 7425		ec.Error(ctx, err)
 7426		return graphql.Null
 7427	}
 7428	if resTmp == nil {
 7429		if !ec.HasError(rctx) {
 7430			ec.Errorf(ctx, "must not be null")
 7431		}
 7432		return graphql.Null
 7433	}
 7434	res := resTmp.(*bug.CreateOperation)
 7435	rctx.Result = res
 7436	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7437	return ec.marshalNCreateOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCreateOperation(ctx, field.Selections, res)
 7438}
 7439
 7440func (ec *executionContext) _OpenBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) (ret graphql.Marshaler) {
 7441	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7442	defer func() {
 7443		if r := recover(); r != nil {
 7444			ec.Error(ctx, ec.Recover(ctx, r))
 7445			ret = graphql.Null
 7446		}
 7447		ec.Tracer.EndFieldExecution(ctx)
 7448	}()
 7449	rctx := &graphql.ResolverContext{
 7450		Object:   "OpenBugPayload",
 7451		Field:    field,
 7452		Args:     nil,
 7453		IsMethod: false,
 7454	}
 7455	ctx = graphql.WithResolverContext(ctx, rctx)
 7456	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7457	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7458		ctx = rctx // use context from middleware stack in children
 7459		return obj.ClientMutationID, nil
 7460	})
 7461	if err != nil {
 7462		ec.Error(ctx, err)
 7463		return graphql.Null
 7464	}
 7465	if resTmp == nil {
 7466		return graphql.Null
 7467	}
 7468	res := resTmp.(*string)
 7469	rctx.Result = res
 7470	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7471	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 7472}
 7473
 7474func (ec *executionContext) _OpenBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) (ret graphql.Marshaler) {
 7475	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7476	defer func() {
 7477		if r := recover(); r != nil {
 7478			ec.Error(ctx, ec.Recover(ctx, r))
 7479			ret = graphql.Null
 7480		}
 7481		ec.Tracer.EndFieldExecution(ctx)
 7482	}()
 7483	rctx := &graphql.ResolverContext{
 7484		Object:   "OpenBugPayload",
 7485		Field:    field,
 7486		Args:     nil,
 7487		IsMethod: false,
 7488	}
 7489	ctx = graphql.WithResolverContext(ctx, rctx)
 7490	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7491	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7492		ctx = rctx // use context from middleware stack in children
 7493		return obj.Bug, nil
 7494	})
 7495	if err != nil {
 7496		ec.Error(ctx, err)
 7497		return graphql.Null
 7498	}
 7499	if resTmp == nil {
 7500		if !ec.HasError(rctx) {
 7501			ec.Errorf(ctx, "must not be null")
 7502		}
 7503		return graphql.Null
 7504	}
 7505	res := resTmp.(*bug.Snapshot)
 7506	rctx.Result = res
 7507	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7508	return ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
 7509}
 7510
 7511func (ec *executionContext) _OpenBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) (ret graphql.Marshaler) {
 7512	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7513	defer func() {
 7514		if r := recover(); r != nil {
 7515			ec.Error(ctx, ec.Recover(ctx, r))
 7516			ret = graphql.Null
 7517		}
 7518		ec.Tracer.EndFieldExecution(ctx)
 7519	}()
 7520	rctx := &graphql.ResolverContext{
 7521		Object:   "OpenBugPayload",
 7522		Field:    field,
 7523		Args:     nil,
 7524		IsMethod: false,
 7525	}
 7526	ctx = graphql.WithResolverContext(ctx, rctx)
 7527	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7528	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7529		ctx = rctx // use context from middleware stack in children
 7530		return obj.Operation, nil
 7531	})
 7532	if err != nil {
 7533		ec.Error(ctx, err)
 7534		return graphql.Null
 7535	}
 7536	if resTmp == nil {
 7537		if !ec.HasError(rctx) {
 7538			ec.Errorf(ctx, "must not be null")
 7539		}
 7540		return graphql.Null
 7541	}
 7542	res := resTmp.(*bug.SetStatusOperation)
 7543	rctx.Result = res
 7544	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7545	return ec.marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
 7546}
 7547
 7548func (ec *executionContext) _OperationConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
 7549	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7550	defer func() {
 7551		if r := recover(); r != nil {
 7552			ec.Error(ctx, ec.Recover(ctx, r))
 7553			ret = graphql.Null
 7554		}
 7555		ec.Tracer.EndFieldExecution(ctx)
 7556	}()
 7557	rctx := &graphql.ResolverContext{
 7558		Object:   "OperationConnection",
 7559		Field:    field,
 7560		Args:     nil,
 7561		IsMethod: false,
 7562	}
 7563	ctx = graphql.WithResolverContext(ctx, rctx)
 7564	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7565	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7566		ctx = rctx // use context from middleware stack in children
 7567		return obj.Edges, nil
 7568	})
 7569	if err != nil {
 7570		ec.Error(ctx, err)
 7571		return graphql.Null
 7572	}
 7573	if resTmp == nil {
 7574		if !ec.HasError(rctx) {
 7575			ec.Errorf(ctx, "must not be null")
 7576		}
 7577		return graphql.Null
 7578	}
 7579	res := resTmp.([]*models.OperationEdge)
 7580	rctx.Result = res
 7581	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7582	return ec.marshalNOperationEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx, field.Selections, res)
 7583}
 7584
 7585func (ec *executionContext) _OperationConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
 7586	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7587	defer func() {
 7588		if r := recover(); r != nil {
 7589			ec.Error(ctx, ec.Recover(ctx, r))
 7590			ret = graphql.Null
 7591		}
 7592		ec.Tracer.EndFieldExecution(ctx)
 7593	}()
 7594	rctx := &graphql.ResolverContext{
 7595		Object:   "OperationConnection",
 7596		Field:    field,
 7597		Args:     nil,
 7598		IsMethod: false,
 7599	}
 7600	ctx = graphql.WithResolverContext(ctx, rctx)
 7601	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7602	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7603		ctx = rctx // use context from middleware stack in children
 7604		return obj.Nodes, nil
 7605	})
 7606	if err != nil {
 7607		ec.Error(ctx, err)
 7608		return graphql.Null
 7609	}
 7610	if resTmp == nil {
 7611		if !ec.HasError(rctx) {
 7612			ec.Errorf(ctx, "must not be null")
 7613		}
 7614		return graphql.Null
 7615	}
 7616	res := resTmp.([]bug.Operation)
 7617	rctx.Result = res
 7618	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7619	return ec.marshalNOperation2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx, field.Selections, res)
 7620}
 7621
 7622func (ec *executionContext) _OperationConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
 7623	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7624	defer func() {
 7625		if r := recover(); r != nil {
 7626			ec.Error(ctx, ec.Recover(ctx, r))
 7627			ret = graphql.Null
 7628		}
 7629		ec.Tracer.EndFieldExecution(ctx)
 7630	}()
 7631	rctx := &graphql.ResolverContext{
 7632		Object:   "OperationConnection",
 7633		Field:    field,
 7634		Args:     nil,
 7635		IsMethod: false,
 7636	}
 7637	ctx = graphql.WithResolverContext(ctx, rctx)
 7638	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7639	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7640		ctx = rctx // use context from middleware stack in children
 7641		return obj.PageInfo, nil
 7642	})
 7643	if err != nil {
 7644		ec.Error(ctx, err)
 7645		return graphql.Null
 7646	}
 7647	if resTmp == nil {
 7648		if !ec.HasError(rctx) {
 7649			ec.Errorf(ctx, "must not be null")
 7650		}
 7651		return graphql.Null
 7652	}
 7653	res := resTmp.(*models.PageInfo)
 7654	rctx.Result = res
 7655	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7656	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
 7657}
 7658
 7659func (ec *executionContext) _OperationConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) (ret graphql.Marshaler) {
 7660	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7661	defer func() {
 7662		if r := recover(); r != nil {
 7663			ec.Error(ctx, ec.Recover(ctx, r))
 7664			ret = graphql.Null
 7665		}
 7666		ec.Tracer.EndFieldExecution(ctx)
 7667	}()
 7668	rctx := &graphql.ResolverContext{
 7669		Object:   "OperationConnection",
 7670		Field:    field,
 7671		Args:     nil,
 7672		IsMethod: false,
 7673	}
 7674	ctx = graphql.WithResolverContext(ctx, rctx)
 7675	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7676	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7677		ctx = rctx // use context from middleware stack in children
 7678		return obj.TotalCount, nil
 7679	})
 7680	if err != nil {
 7681		ec.Error(ctx, err)
 7682		return graphql.Null
 7683	}
 7684	if resTmp == nil {
 7685		if !ec.HasError(rctx) {
 7686			ec.Errorf(ctx, "must not be null")
 7687		}
 7688		return graphql.Null
 7689	}
 7690	res := resTmp.(int)
 7691	rctx.Result = res
 7692	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7693	return ec.marshalNInt2int(ctx, field.Selections, res)
 7694}
 7695
 7696func (ec *executionContext) _OperationEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.OperationEdge) (ret graphql.Marshaler) {
 7697	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7698	defer func() {
 7699		if r := recover(); r != nil {
 7700			ec.Error(ctx, ec.Recover(ctx, r))
 7701			ret = graphql.Null
 7702		}
 7703		ec.Tracer.EndFieldExecution(ctx)
 7704	}()
 7705	rctx := &graphql.ResolverContext{
 7706		Object:   "OperationEdge",
 7707		Field:    field,
 7708		Args:     nil,
 7709		IsMethod: false,
 7710	}
 7711	ctx = graphql.WithResolverContext(ctx, rctx)
 7712	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7713	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7714		ctx = rctx // use context from middleware stack in children
 7715		return obj.Cursor, nil
 7716	})
 7717	if err != nil {
 7718		ec.Error(ctx, err)
 7719		return graphql.Null
 7720	}
 7721	if resTmp == nil {
 7722		if !ec.HasError(rctx) {
 7723			ec.Errorf(ctx, "must not be null")
 7724		}
 7725		return graphql.Null
 7726	}
 7727	res := resTmp.(string)
 7728	rctx.Result = res
 7729	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7730	return ec.marshalNString2string(ctx, field.Selections, res)
 7731}
 7732
 7733func (ec *executionContext) _OperationEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.OperationEdge) (ret graphql.Marshaler) {
 7734	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7735	defer func() {
 7736		if r := recover(); r != nil {
 7737			ec.Error(ctx, ec.Recover(ctx, r))
 7738			ret = graphql.Null
 7739		}
 7740		ec.Tracer.EndFieldExecution(ctx)
 7741	}()
 7742	rctx := &graphql.ResolverContext{
 7743		Object:   "OperationEdge",
 7744		Field:    field,
 7745		Args:     nil,
 7746		IsMethod: false,
 7747	}
 7748	ctx = graphql.WithResolverContext(ctx, rctx)
 7749	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7750	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7751		ctx = rctx // use context from middleware stack in children
 7752		return obj.Node, nil
 7753	})
 7754	if err != nil {
 7755		ec.Error(ctx, err)
 7756		return graphql.Null
 7757	}
 7758	if resTmp == nil {
 7759		if !ec.HasError(rctx) {
 7760			ec.Errorf(ctx, "must not be null")
 7761		}
 7762		return graphql.Null
 7763	}
 7764	res := resTmp.(bug.Operation)
 7765	rctx.Result = res
 7766	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7767	return ec.marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx, field.Selections, res)
 7768}
 7769
 7770func (ec *executionContext) _PageInfo_hasNextPage(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
 7771	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7772	defer func() {
 7773		if r := recover(); r != nil {
 7774			ec.Error(ctx, ec.Recover(ctx, r))
 7775			ret = graphql.Null
 7776		}
 7777		ec.Tracer.EndFieldExecution(ctx)
 7778	}()
 7779	rctx := &graphql.ResolverContext{
 7780		Object:   "PageInfo",
 7781		Field:    field,
 7782		Args:     nil,
 7783		IsMethod: false,
 7784	}
 7785	ctx = graphql.WithResolverContext(ctx, rctx)
 7786	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7787	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7788		ctx = rctx // use context from middleware stack in children
 7789		return obj.HasNextPage, nil
 7790	})
 7791	if err != nil {
 7792		ec.Error(ctx, err)
 7793		return graphql.Null
 7794	}
 7795	if resTmp == nil {
 7796		if !ec.HasError(rctx) {
 7797			ec.Errorf(ctx, "must not be null")
 7798		}
 7799		return graphql.Null
 7800	}
 7801	res := resTmp.(bool)
 7802	rctx.Result = res
 7803	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7804	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 7805}
 7806
 7807func (ec *executionContext) _PageInfo_hasPreviousPage(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
 7808	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7809	defer func() {
 7810		if r := recover(); r != nil {
 7811			ec.Error(ctx, ec.Recover(ctx, r))
 7812			ret = graphql.Null
 7813		}
 7814		ec.Tracer.EndFieldExecution(ctx)
 7815	}()
 7816	rctx := &graphql.ResolverContext{
 7817		Object:   "PageInfo",
 7818		Field:    field,
 7819		Args:     nil,
 7820		IsMethod: false,
 7821	}
 7822	ctx = graphql.WithResolverContext(ctx, rctx)
 7823	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7824	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7825		ctx = rctx // use context from middleware stack in children
 7826		return obj.HasPreviousPage, nil
 7827	})
 7828	if err != nil {
 7829		ec.Error(ctx, err)
 7830		return graphql.Null
 7831	}
 7832	if resTmp == nil {
 7833		if !ec.HasError(rctx) {
 7834			ec.Errorf(ctx, "must not be null")
 7835		}
 7836		return graphql.Null
 7837	}
 7838	res := resTmp.(bool)
 7839	rctx.Result = res
 7840	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7841	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 7842}
 7843
 7844func (ec *executionContext) _PageInfo_startCursor(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
 7845	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7846	defer func() {
 7847		if r := recover(); r != nil {
 7848			ec.Error(ctx, ec.Recover(ctx, r))
 7849			ret = graphql.Null
 7850		}
 7851		ec.Tracer.EndFieldExecution(ctx)
 7852	}()
 7853	rctx := &graphql.ResolverContext{
 7854		Object:   "PageInfo",
 7855		Field:    field,
 7856		Args:     nil,
 7857		IsMethod: false,
 7858	}
 7859	ctx = graphql.WithResolverContext(ctx, rctx)
 7860	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7861	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7862		ctx = rctx // use context from middleware stack in children
 7863		return obj.StartCursor, nil
 7864	})
 7865	if err != nil {
 7866		ec.Error(ctx, err)
 7867		return graphql.Null
 7868	}
 7869	if resTmp == nil {
 7870		if !ec.HasError(rctx) {
 7871			ec.Errorf(ctx, "must not be null")
 7872		}
 7873		return graphql.Null
 7874	}
 7875	res := resTmp.(string)
 7876	rctx.Result = res
 7877	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7878	return ec.marshalNString2string(ctx, field.Selections, res)
 7879}
 7880
 7881func (ec *executionContext) _PageInfo_endCursor(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) (ret graphql.Marshaler) {
 7882	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7883	defer func() {
 7884		if r := recover(); r != nil {
 7885			ec.Error(ctx, ec.Recover(ctx, r))
 7886			ret = graphql.Null
 7887		}
 7888		ec.Tracer.EndFieldExecution(ctx)
 7889	}()
 7890	rctx := &graphql.ResolverContext{
 7891		Object:   "PageInfo",
 7892		Field:    field,
 7893		Args:     nil,
 7894		IsMethod: false,
 7895	}
 7896	ctx = graphql.WithResolverContext(ctx, rctx)
 7897	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7898	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7899		ctx = rctx // use context from middleware stack in children
 7900		return obj.EndCursor, nil
 7901	})
 7902	if err != nil {
 7903		ec.Error(ctx, err)
 7904		return graphql.Null
 7905	}
 7906	if resTmp == nil {
 7907		if !ec.HasError(rctx) {
 7908			ec.Errorf(ctx, "must not be null")
 7909		}
 7910		return graphql.Null
 7911	}
 7912	res := resTmp.(string)
 7913	rctx.Result = res
 7914	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7915	return ec.marshalNString2string(ctx, field.Selections, res)
 7916}
 7917
 7918func (ec *executionContext) _Query_defaultRepository(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 7919	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7920	defer func() {
 7921		if r := recover(); r != nil {
 7922			ec.Error(ctx, ec.Recover(ctx, r))
 7923			ret = graphql.Null
 7924		}
 7925		ec.Tracer.EndFieldExecution(ctx)
 7926	}()
 7927	rctx := &graphql.ResolverContext{
 7928		Object:   "Query",
 7929		Field:    field,
 7930		Args:     nil,
 7931		IsMethod: true,
 7932	}
 7933	ctx = graphql.WithResolverContext(ctx, rctx)
 7934	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7935	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7936		ctx = rctx // use context from middleware stack in children
 7937		return ec.resolvers.Query().DefaultRepository(rctx)
 7938	})
 7939	if err != nil {
 7940		ec.Error(ctx, err)
 7941		return graphql.Null
 7942	}
 7943	if resTmp == nil {
 7944		return graphql.Null
 7945	}
 7946	res := resTmp.(*models.Repository)
 7947	rctx.Result = res
 7948	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7949	return ec.marshalORepository2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRepository(ctx, field.Selections, res)
 7950}
 7951
 7952func (ec *executionContext) _Query_repository(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 7953	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7954	defer func() {
 7955		if r := recover(); r != nil {
 7956			ec.Error(ctx, ec.Recover(ctx, r))
 7957			ret = graphql.Null
 7958		}
 7959		ec.Tracer.EndFieldExecution(ctx)
 7960	}()
 7961	rctx := &graphql.ResolverContext{
 7962		Object:   "Query",
 7963		Field:    field,
 7964		Args:     nil,
 7965		IsMethod: true,
 7966	}
 7967	ctx = graphql.WithResolverContext(ctx, rctx)
 7968	rawArgs := field.ArgumentMap(ec.Variables)
 7969	args, err := ec.field_Query_repository_args(ctx, rawArgs)
 7970	if err != nil {
 7971		ec.Error(ctx, err)
 7972		return graphql.Null
 7973	}
 7974	rctx.Args = args
 7975	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7976	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 7977		ctx = rctx // use context from middleware stack in children
 7978		return ec.resolvers.Query().Repository(rctx, args["ref"].(string))
 7979	})
 7980	if err != nil {
 7981		ec.Error(ctx, err)
 7982		return graphql.Null
 7983	}
 7984	if resTmp == nil {
 7985		return graphql.Null
 7986	}
 7987	res := resTmp.(*models.Repository)
 7988	rctx.Result = res
 7989	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7990	return ec.marshalORepository2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRepository(ctx, field.Selections, res)
 7991}
 7992
 7993func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 7994	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7995	defer func() {
 7996		if r := recover(); r != nil {
 7997			ec.Error(ctx, ec.Recover(ctx, r))
 7998			ret = graphql.Null
 7999		}
 8000		ec.Tracer.EndFieldExecution(ctx)
 8001	}()
 8002	rctx := &graphql.ResolverContext{
 8003		Object:   "Query",
 8004		Field:    field,
 8005		Args:     nil,
 8006		IsMethod: true,
 8007	}
 8008	ctx = graphql.WithResolverContext(ctx, rctx)
 8009	rawArgs := field.ArgumentMap(ec.Variables)
 8010	args, err := ec.field_Query___type_args(ctx, rawArgs)
 8011	if err != nil {
 8012		ec.Error(ctx, err)
 8013		return graphql.Null
 8014	}
 8015	rctx.Args = args
 8016	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 8017	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8018		ctx = rctx // use context from middleware stack in children
 8019		return ec.introspectType(args["name"].(string))
 8020	})
 8021	if err != nil {
 8022		ec.Error(ctx, err)
 8023		return graphql.Null
 8024	}
 8025	if resTmp == nil {
 8026		return graphql.Null
 8027	}
 8028	res := resTmp.(*introspection.Type)
 8029	rctx.Result = res
 8030	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 8031	return ec.marshalO__Type2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
 8032}
 8033
 8034func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
 8035	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 8036	defer func() {
 8037		if r := recover(); r != nil {
 8038			ec.Error(ctx, ec.Recover(ctx, r))
 8039			ret = graphql.Null
 8040		}
 8041		ec.Tracer.EndFieldExecution(ctx)
 8042	}()
 8043	rctx := &graphql.ResolverContext{
 8044		Object:   "Query",
 8045		Field:    field,
 8046		Args:     nil,
 8047		IsMethod: true,
 8048	}
 8049	ctx = graphql.WithResolverContext(ctx, rctx)
 8050	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 8051	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8052		ctx = rctx // use context from middleware stack in children
 8053		return ec.introspectSchema()
 8054	})
 8055	if err != nil {
 8056		ec.Error(ctx, err)
 8057		return graphql.Null
 8058	}
 8059	if resTmp == nil {
 8060		return graphql.Null
 8061	}
 8062	res := resTmp.(*introspection.Schema)
 8063	rctx.Result = res
 8064	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 8065	return ec.marshalO__Schema2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx, field.Selections, res)
 8066}
 8067
 8068func (ec *executionContext) _Repository_allBugs(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 8069	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 8070	defer func() {
 8071		if r := recover(); r != nil {
 8072			ec.Error(ctx, ec.Recover(ctx, r))
 8073			ret = graphql.Null
 8074		}
 8075		ec.Tracer.EndFieldExecution(ctx)
 8076	}()
 8077	rctx := &graphql.ResolverContext{
 8078		Object:   "Repository",
 8079		Field:    field,
 8080		Args:     nil,
 8081		IsMethod: true,
 8082	}
 8083	ctx = graphql.WithResolverContext(ctx, rctx)
 8084	rawArgs := field.ArgumentMap(ec.Variables)
 8085	args, err := ec.field_Repository_allBugs_args(ctx, rawArgs)
 8086	if err != nil {
 8087		ec.Error(ctx, err)
 8088		return graphql.Null
 8089	}
 8090	rctx.Args = args
 8091	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 8092	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8093		ctx = rctx // use context from middleware stack in children
 8094		return ec.resolvers.Repository().AllBugs(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int), args["query"].(*string))
 8095	})
 8096	if err != nil {
 8097		ec.Error(ctx, err)
 8098		return graphql.Null
 8099	}
 8100	if resTmp == nil {
 8101		if !ec.HasError(rctx) {
 8102			ec.Errorf(ctx, "must not be null")
 8103		}
 8104		return graphql.Null
 8105	}
 8106	res := resTmp.(*models.BugConnection)
 8107	rctx.Result = res
 8108	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 8109	return ec.marshalNBugConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugConnection(ctx, field.Selections, res)
 8110}
 8111
 8112func (ec *executionContext) _Repository_bug(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 8113	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 8114	defer func() {
 8115		if r := recover(); r != nil {
 8116			ec.Error(ctx, ec.Recover(ctx, r))
 8117			ret = graphql.Null
 8118		}
 8119		ec.Tracer.EndFieldExecution(ctx)
 8120	}()
 8121	rctx := &graphql.ResolverContext{
 8122		Object:   "Repository",
 8123		Field:    field,
 8124		Args:     nil,
 8125		IsMethod: true,
 8126	}
 8127	ctx = graphql.WithResolverContext(ctx, rctx)
 8128	rawArgs := field.ArgumentMap(ec.Variables)
 8129	args, err := ec.field_Repository_bug_args(ctx, rawArgs)
 8130	if err != nil {
 8131		ec.Error(ctx, err)
 8132		return graphql.Null
 8133	}
 8134	rctx.Args = args
 8135	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 8136	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8137		ctx = rctx // use context from middleware stack in children
 8138		return ec.resolvers.Repository().Bug(rctx, obj, args["prefix"].(string))
 8139	})
 8140	if err != nil {
 8141		ec.Error(ctx, err)
 8142		return graphql.Null
 8143	}
 8144	if resTmp == nil {
 8145		return graphql.Null
 8146	}
 8147	res := resTmp.(*bug.Snapshot)
 8148	rctx.Result = res
 8149	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 8150	return ec.marshalOBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
 8151}
 8152
 8153func (ec *executionContext) _Repository_allIdentities(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 8154	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 8155	defer func() {
 8156		if r := recover(); r != nil {
 8157			ec.Error(ctx, ec.Recover(ctx, r))
 8158			ret = graphql.Null
 8159		}
 8160		ec.Tracer.EndFieldExecution(ctx)
 8161	}()
 8162	rctx := &graphql.ResolverContext{
 8163		Object:   "Repository",
 8164		Field:    field,
 8165		Args:     nil,
 8166		IsMethod: true,
 8167	}
 8168	ctx = graphql.WithResolverContext(ctx, rctx)
 8169	rawArgs := field.ArgumentMap(ec.Variables)
 8170	args, err := ec.field_Repository_allIdentities_args(ctx, rawArgs)
 8171	if err != nil {
 8172		ec.Error(ctx, err)
 8173		return graphql.Null
 8174	}
 8175	rctx.Args = args
 8176	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 8177	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8178		ctx = rctx // use context from middleware stack in children
 8179		return ec.resolvers.Repository().AllIdentities(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
 8180	})
 8181	if err != nil {
 8182		ec.Error(ctx, err)
 8183		return graphql.Null
 8184	}
 8185	if resTmp == nil {
 8186		if !ec.HasError(rctx) {
 8187			ec.Errorf(ctx, "must not be null")
 8188		}
 8189		return graphql.Null
 8190	}
 8191	res := resTmp.(*models.IdentityConnection)
 8192	rctx.Result = res
 8193	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 8194	return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
 8195}
 8196
 8197func (ec *executionContext) _Repository_identity(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 8198	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 8199	defer func() {
 8200		if r := recover(); r != nil {
 8201			ec.Error(ctx, ec.Recover(ctx, r))
 8202			ret = graphql.Null
 8203		}
 8204		ec.Tracer.EndFieldExecution(ctx)
 8205	}()
 8206	rctx := &graphql.ResolverContext{
 8207		Object:   "Repository",
 8208		Field:    field,
 8209		Args:     nil,
 8210		IsMethod: true,
 8211	}
 8212	ctx = graphql.WithResolverContext(ctx, rctx)
 8213	rawArgs := field.ArgumentMap(ec.Variables)
 8214	args, err := ec.field_Repository_identity_args(ctx, rawArgs)
 8215	if err != nil {
 8216		ec.Error(ctx, err)
 8217		return graphql.Null
 8218	}
 8219	rctx.Args = args
 8220	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 8221	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8222		ctx = rctx // use context from middleware stack in children
 8223		return ec.resolvers.Repository().Identity(rctx, obj, args["prefix"].(string))
 8224	})
 8225	if err != nil {
 8226		ec.Error(ctx, err)
 8227		return graphql.Null
 8228	}
 8229	if resTmp == nil {
 8230		return graphql.Null
 8231	}
 8232	res := resTmp.(identity.Interface)
 8233	rctx.Result = res
 8234	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 8235	return ec.marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
 8236}
 8237
 8238func (ec *executionContext) _Repository_userIdentity(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 8239	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 8240	defer func() {
 8241		if r := recover(); r != nil {
 8242			ec.Error(ctx, ec.Recover(ctx, r))
 8243			ret = graphql.Null
 8244		}
 8245		ec.Tracer.EndFieldExecution(ctx)
 8246	}()
 8247	rctx := &graphql.ResolverContext{
 8248		Object:   "Repository",
 8249		Field:    field,
 8250		Args:     nil,
 8251		IsMethod: true,
 8252	}
 8253	ctx = graphql.WithResolverContext(ctx, rctx)
 8254	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 8255	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8256		ctx = rctx // use context from middleware stack in children
 8257		return ec.resolvers.Repository().UserIdentity(rctx, obj)
 8258	})
 8259	if err != nil {
 8260		ec.Error(ctx, err)
 8261		return graphql.Null
 8262	}
 8263	if resTmp == nil {
 8264		return graphql.Null
 8265	}
 8266	res := resTmp.(identity.Interface)
 8267	rctx.Result = res
 8268	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 8269	return ec.marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
 8270}
 8271
 8272func (ec *executionContext) _Repository_validLabels(ctx context.Context, field graphql.CollectedField, obj *models.Repository) (ret graphql.Marshaler) {
 8273	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 8274	defer func() {
 8275		if r := recover(); r != nil {
 8276			ec.Error(ctx, ec.Recover(ctx, r))
 8277			ret = graphql.Null
 8278		}
 8279		ec.Tracer.EndFieldExecution(ctx)
 8280	}()
 8281	rctx := &graphql.ResolverContext{
 8282		Object:   "Repository",
 8283		Field:    field,
 8284		Args:     nil,
 8285		IsMethod: true,
 8286	}
 8287	ctx = graphql.WithResolverContext(ctx, rctx)
 8288	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 8289	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8290		ctx = rctx // use context from middleware stack in children
 8291		return ec.resolvers.Repository().ValidLabels(rctx, obj)
 8292	})
 8293	if err != nil {
 8294		ec.Error(ctx, err)
 8295		return graphql.Null
 8296	}
 8297	if resTmp == nil {
 8298		if !ec.HasError(rctx) {
 8299			ec.Errorf(ctx, "must not be null")
 8300		}
 8301		return graphql.Null
 8302	}
 8303	res := resTmp.([]bug.Label)
 8304	rctx.Result = res
 8305	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 8306	return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
 8307}
 8308
 8309func (ec *executionContext) _SetStatusOperation_hash(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
 8310	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 8311	defer func() {
 8312		if r := recover(); r != nil {
 8313			ec.Error(ctx, ec.Recover(ctx, r))
 8314			ret = graphql.Null
 8315		}
 8316		ec.Tracer.EndFieldExecution(ctx)
 8317	}()
 8318	rctx := &graphql.ResolverContext{
 8319		Object:   "SetStatusOperation",
 8320		Field:    field,
 8321		Args:     nil,
 8322		IsMethod: true,
 8323	}
 8324	ctx = graphql.WithResolverContext(ctx, rctx)
 8325	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 8326	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8327		ctx = rctx // use context from middleware stack in children
 8328		return obj.Hash()
 8329	})
 8330	if err != nil {
 8331		ec.Error(ctx, err)
 8332		return graphql.Null
 8333	}
 8334	if resTmp == nil {
 8335		if !ec.HasError(rctx) {
 8336			ec.Errorf(ctx, "must not be null")
 8337		}
 8338		return graphql.Null
 8339	}
 8340	res := resTmp.(git.Hash)
 8341	rctx.Result = res
 8342	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 8343	return ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
 8344}
 8345
 8346func (ec *executionContext) _SetStatusOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
 8347	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 8348	defer func() {
 8349		if r := recover(); r != nil {
 8350			ec.Error(ctx, ec.Recover(ctx, r))
 8351			ret = graphql.Null
 8352		}
 8353		ec.Tracer.EndFieldExecution(ctx)
 8354	}()
 8355	rctx := &graphql.ResolverContext{
 8356		Object:   "SetStatusOperation",
 8357		Field:    field,
 8358		Args:     nil,
 8359		IsMethod: false,
 8360	}
 8361	ctx = graphql.WithResolverContext(ctx, rctx)
 8362	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 8363	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8364		ctx = rctx // use context from middleware stack in children
 8365		return obj.Author, nil
 8366	})
 8367	if err != nil {
 8368		ec.Error(ctx, err)
 8369		return graphql.Null
 8370	}
 8371	if resTmp == nil {
 8372		if !ec.HasError(rctx) {
 8373			ec.Errorf(ctx, "must not be null")
 8374		}
 8375		return graphql.Null
 8376	}
 8377	res := resTmp.(identity.Interface)
 8378	rctx.Result = res
 8379	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 8380	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
 8381}
 8382
 8383func (ec *executionContext) _SetStatusOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
 8384	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 8385	defer func() {
 8386		if r := recover(); r != nil {
 8387			ec.Error(ctx, ec.Recover(ctx, r))
 8388			ret = graphql.Null
 8389		}
 8390		ec.Tracer.EndFieldExecution(ctx)
 8391	}()
 8392	rctx := &graphql.ResolverContext{
 8393		Object:   "SetStatusOperation",
 8394		Field:    field,
 8395		Args:     nil,
 8396		IsMethod: true,
 8397	}
 8398	ctx = graphql.WithResolverContext(ctx, rctx)
 8399	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 8400	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8401		ctx = rctx // use context from middleware stack in children
 8402		return ec.resolvers.SetStatusOperation().Date(rctx, obj)
 8403	})
 8404	if err != nil {
 8405		ec.Error(ctx, err)
 8406		return graphql.Null
 8407	}
 8408	if resTmp == nil {
 8409		if !ec.HasError(rctx) {
 8410			ec.Errorf(ctx, "must not be null")
 8411		}
 8412		return graphql.Null
 8413	}
 8414	res := resTmp.(*time.Time)
 8415	rctx.Result = res
 8416	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 8417	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 8418}
 8419
 8420func (ec *executionContext) _SetStatusOperation_status(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) (ret graphql.Marshaler) {
 8421	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 8422	defer func() {
 8423		if r := recover(); r != nil {
 8424			ec.Error(ctx, ec.Recover(ctx, r))
 8425			ret = graphql.Null
 8426		}
 8427		ec.Tracer.EndFieldExecution(ctx)
 8428	}()
 8429	rctx := &graphql.ResolverContext{
 8430		Object:   "SetStatusOperation",
 8431		Field:    field,
 8432		Args:     nil,
 8433		IsMethod: true,
 8434	}
 8435	ctx = graphql.WithResolverContext(ctx, rctx)
 8436	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 8437	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8438		ctx = rctx // use context from middleware stack in children
 8439		return ec.resolvers.SetStatusOperation().Status(rctx, obj)
 8440	})
 8441	if err != nil {
 8442		ec.Error(ctx, err)
 8443		return graphql.Null
 8444	}
 8445	if resTmp == nil {
 8446		if !ec.HasError(rctx) {
 8447			ec.Errorf(ctx, "must not be null")
 8448		}
 8449		return graphql.Null
 8450	}
 8451	res := resTmp.(models.Status)
 8452	rctx.Result = res
 8453	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 8454	return ec.marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx, field.Selections, res)
 8455}
 8456
 8457func (ec *executionContext) _SetStatusTimelineItem_hash(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
 8458	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 8459	defer func() {
 8460		if r := recover(); r != nil {
 8461			ec.Error(ctx, ec.Recover(ctx, r))
 8462			ret = graphql.Null
 8463		}
 8464		ec.Tracer.EndFieldExecution(ctx)
 8465	}()
 8466	rctx := &graphql.ResolverContext{
 8467		Object:   "SetStatusTimelineItem",
 8468		Field:    field,
 8469		Args:     nil,
 8470		IsMethod: true,
 8471	}
 8472	ctx = graphql.WithResolverContext(ctx, rctx)
 8473	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 8474	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8475		ctx = rctx // use context from middleware stack in children
 8476		return obj.Hash(), nil
 8477	})
 8478	if err != nil {
 8479		ec.Error(ctx, err)
 8480		return graphql.Null
 8481	}
 8482	if resTmp == nil {
 8483		if !ec.HasError(rctx) {
 8484			ec.Errorf(ctx, "must not be null")
 8485		}
 8486		return graphql.Null
 8487	}
 8488	res := resTmp.(git.Hash)
 8489	rctx.Result = res
 8490	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 8491	return ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
 8492}
 8493
 8494func (ec *executionContext) _SetStatusTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
 8495	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 8496	defer func() {
 8497		if r := recover(); r != nil {
 8498			ec.Error(ctx, ec.Recover(ctx, r))
 8499			ret = graphql.Null
 8500		}
 8501		ec.Tracer.EndFieldExecution(ctx)
 8502	}()
 8503	rctx := &graphql.ResolverContext{
 8504		Object:   "SetStatusTimelineItem",
 8505		Field:    field,
 8506		Args:     nil,
 8507		IsMethod: false,
 8508	}
 8509	ctx = graphql.WithResolverContext(ctx, rctx)
 8510	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 8511	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8512		ctx = rctx // use context from middleware stack in children
 8513		return obj.Author, nil
 8514	})
 8515	if err != nil {
 8516		ec.Error(ctx, err)
 8517		return graphql.Null
 8518	}
 8519	if resTmp == nil {
 8520		if !ec.HasError(rctx) {
 8521			ec.Errorf(ctx, "must not be null")
 8522		}
 8523		return graphql.Null
 8524	}
 8525	res := resTmp.(identity.Interface)
 8526	rctx.Result = res
 8527	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 8528	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
 8529}
 8530
 8531func (ec *executionContext) _SetStatusTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
 8532	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 8533	defer func() {
 8534		if r := recover(); r != nil {
 8535			ec.Error(ctx, ec.Recover(ctx, r))
 8536			ret = graphql.Null
 8537		}
 8538		ec.Tracer.EndFieldExecution(ctx)
 8539	}()
 8540	rctx := &graphql.ResolverContext{
 8541		Object:   "SetStatusTimelineItem",
 8542		Field:    field,
 8543		Args:     nil,
 8544		IsMethod: true,
 8545	}
 8546	ctx = graphql.WithResolverContext(ctx, rctx)
 8547	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 8548	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8549		ctx = rctx // use context from middleware stack in children
 8550		return ec.resolvers.SetStatusTimelineItem().Date(rctx, obj)
 8551	})
 8552	if err != nil {
 8553		ec.Error(ctx, err)
 8554		return graphql.Null
 8555	}
 8556	if resTmp == nil {
 8557		if !ec.HasError(rctx) {
 8558			ec.Errorf(ctx, "must not be null")
 8559		}
 8560		return graphql.Null
 8561	}
 8562	res := resTmp.(*time.Time)
 8563	rctx.Result = res
 8564	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 8565	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 8566}
 8567
 8568func (ec *executionContext) _SetStatusTimelineItem_status(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) (ret graphql.Marshaler) {
 8569	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 8570	defer func() {
 8571		if r := recover(); r != nil {
 8572			ec.Error(ctx, ec.Recover(ctx, r))
 8573			ret = graphql.Null
 8574		}
 8575		ec.Tracer.EndFieldExecution(ctx)
 8576	}()
 8577	rctx := &graphql.ResolverContext{
 8578		Object:   "SetStatusTimelineItem",
 8579		Field:    field,
 8580		Args:     nil,
 8581		IsMethod: true,
 8582	}
 8583	ctx = graphql.WithResolverContext(ctx, rctx)
 8584	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 8585	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8586		ctx = rctx // use context from middleware stack in children
 8587		return ec.resolvers.SetStatusTimelineItem().Status(rctx, obj)
 8588	})
 8589	if err != nil {
 8590		ec.Error(ctx, err)
 8591		return graphql.Null
 8592	}
 8593	if resTmp == nil {
 8594		if !ec.HasError(rctx) {
 8595			ec.Errorf(ctx, "must not be null")
 8596		}
 8597		return graphql.Null
 8598	}
 8599	res := resTmp.(models.Status)
 8600	rctx.Result = res
 8601	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 8602	return ec.marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx, field.Selections, res)
 8603}
 8604
 8605func (ec *executionContext) _SetTitleOperation_hash(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
 8606	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 8607	defer func() {
 8608		if r := recover(); r != nil {
 8609			ec.Error(ctx, ec.Recover(ctx, r))
 8610			ret = graphql.Null
 8611		}
 8612		ec.Tracer.EndFieldExecution(ctx)
 8613	}()
 8614	rctx := &graphql.ResolverContext{
 8615		Object:   "SetTitleOperation",
 8616		Field:    field,
 8617		Args:     nil,
 8618		IsMethod: true,
 8619	}
 8620	ctx = graphql.WithResolverContext(ctx, rctx)
 8621	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 8622	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8623		ctx = rctx // use context from middleware stack in children
 8624		return obj.Hash()
 8625	})
 8626	if err != nil {
 8627		ec.Error(ctx, err)
 8628		return graphql.Null
 8629	}
 8630	if resTmp == nil {
 8631		if !ec.HasError(rctx) {
 8632			ec.Errorf(ctx, "must not be null")
 8633		}
 8634		return graphql.Null
 8635	}
 8636	res := resTmp.(git.Hash)
 8637	rctx.Result = res
 8638	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 8639	return ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
 8640}
 8641
 8642func (ec *executionContext) _SetTitleOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
 8643	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 8644	defer func() {
 8645		if r := recover(); r != nil {
 8646			ec.Error(ctx, ec.Recover(ctx, r))
 8647			ret = graphql.Null
 8648		}
 8649		ec.Tracer.EndFieldExecution(ctx)
 8650	}()
 8651	rctx := &graphql.ResolverContext{
 8652		Object:   "SetTitleOperation",
 8653		Field:    field,
 8654		Args:     nil,
 8655		IsMethod: false,
 8656	}
 8657	ctx = graphql.WithResolverContext(ctx, rctx)
 8658	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 8659	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8660		ctx = rctx // use context from middleware stack in children
 8661		return obj.Author, nil
 8662	})
 8663	if err != nil {
 8664		ec.Error(ctx, err)
 8665		return graphql.Null
 8666	}
 8667	if resTmp == nil {
 8668		if !ec.HasError(rctx) {
 8669			ec.Errorf(ctx, "must not be null")
 8670		}
 8671		return graphql.Null
 8672	}
 8673	res := resTmp.(identity.Interface)
 8674	rctx.Result = res
 8675	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 8676	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
 8677}
 8678
 8679func (ec *executionContext) _SetTitleOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
 8680	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 8681	defer func() {
 8682		if r := recover(); r != nil {
 8683			ec.Error(ctx, ec.Recover(ctx, r))
 8684			ret = graphql.Null
 8685		}
 8686		ec.Tracer.EndFieldExecution(ctx)
 8687	}()
 8688	rctx := &graphql.ResolverContext{
 8689		Object:   "SetTitleOperation",
 8690		Field:    field,
 8691		Args:     nil,
 8692		IsMethod: true,
 8693	}
 8694	ctx = graphql.WithResolverContext(ctx, rctx)
 8695	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 8696	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8697		ctx = rctx // use context from middleware stack in children
 8698		return ec.resolvers.SetTitleOperation().Date(rctx, obj)
 8699	})
 8700	if err != nil {
 8701		ec.Error(ctx, err)
 8702		return graphql.Null
 8703	}
 8704	if resTmp == nil {
 8705		if !ec.HasError(rctx) {
 8706			ec.Errorf(ctx, "must not be null")
 8707		}
 8708		return graphql.Null
 8709	}
 8710	res := resTmp.(*time.Time)
 8711	rctx.Result = res
 8712	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 8713	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 8714}
 8715
 8716func (ec *executionContext) _SetTitleOperation_title(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
 8717	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 8718	defer func() {
 8719		if r := recover(); r != nil {
 8720			ec.Error(ctx, ec.Recover(ctx, r))
 8721			ret = graphql.Null
 8722		}
 8723		ec.Tracer.EndFieldExecution(ctx)
 8724	}()
 8725	rctx := &graphql.ResolverContext{
 8726		Object:   "SetTitleOperation",
 8727		Field:    field,
 8728		Args:     nil,
 8729		IsMethod: false,
 8730	}
 8731	ctx = graphql.WithResolverContext(ctx, rctx)
 8732	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 8733	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8734		ctx = rctx // use context from middleware stack in children
 8735		return obj.Title, nil
 8736	})
 8737	if err != nil {
 8738		ec.Error(ctx, err)
 8739		return graphql.Null
 8740	}
 8741	if resTmp == nil {
 8742		if !ec.HasError(rctx) {
 8743			ec.Errorf(ctx, "must not be null")
 8744		}
 8745		return graphql.Null
 8746	}
 8747	res := resTmp.(string)
 8748	rctx.Result = res
 8749	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 8750	return ec.marshalNString2string(ctx, field.Selections, res)
 8751}
 8752
 8753func (ec *executionContext) _SetTitleOperation_was(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) (ret graphql.Marshaler) {
 8754	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 8755	defer func() {
 8756		if r := recover(); r != nil {
 8757			ec.Error(ctx, ec.Recover(ctx, r))
 8758			ret = graphql.Null
 8759		}
 8760		ec.Tracer.EndFieldExecution(ctx)
 8761	}()
 8762	rctx := &graphql.ResolverContext{
 8763		Object:   "SetTitleOperation",
 8764		Field:    field,
 8765		Args:     nil,
 8766		IsMethod: false,
 8767	}
 8768	ctx = graphql.WithResolverContext(ctx, rctx)
 8769	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 8770	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8771		ctx = rctx // use context from middleware stack in children
 8772		return obj.Was, nil
 8773	})
 8774	if err != nil {
 8775		ec.Error(ctx, err)
 8776		return graphql.Null
 8777	}
 8778	if resTmp == nil {
 8779		if !ec.HasError(rctx) {
 8780			ec.Errorf(ctx, "must not be null")
 8781		}
 8782		return graphql.Null
 8783	}
 8784	res := resTmp.(string)
 8785	rctx.Result = res
 8786	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 8787	return ec.marshalNString2string(ctx, field.Selections, res)
 8788}
 8789
 8790func (ec *executionContext) _SetTitlePayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) (ret graphql.Marshaler) {
 8791	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 8792	defer func() {
 8793		if r := recover(); r != nil {
 8794			ec.Error(ctx, ec.Recover(ctx, r))
 8795			ret = graphql.Null
 8796		}
 8797		ec.Tracer.EndFieldExecution(ctx)
 8798	}()
 8799	rctx := &graphql.ResolverContext{
 8800		Object:   "SetTitlePayload",
 8801		Field:    field,
 8802		Args:     nil,
 8803		IsMethod: false,
 8804	}
 8805	ctx = graphql.WithResolverContext(ctx, rctx)
 8806	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 8807	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8808		ctx = rctx // use context from middleware stack in children
 8809		return obj.ClientMutationID, nil
 8810	})
 8811	if err != nil {
 8812		ec.Error(ctx, err)
 8813		return graphql.Null
 8814	}
 8815	if resTmp == nil {
 8816		return graphql.Null
 8817	}
 8818	res := resTmp.(*string)
 8819	rctx.Result = res
 8820	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 8821	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 8822}
 8823
 8824func (ec *executionContext) _SetTitlePayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) (ret graphql.Marshaler) {
 8825	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 8826	defer func() {
 8827		if r := recover(); r != nil {
 8828			ec.Error(ctx, ec.Recover(ctx, r))
 8829			ret = graphql.Null
 8830		}
 8831		ec.Tracer.EndFieldExecution(ctx)
 8832	}()
 8833	rctx := &graphql.ResolverContext{
 8834		Object:   "SetTitlePayload",
 8835		Field:    field,
 8836		Args:     nil,
 8837		IsMethod: false,
 8838	}
 8839	ctx = graphql.WithResolverContext(ctx, rctx)
 8840	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 8841	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8842		ctx = rctx // use context from middleware stack in children
 8843		return obj.Bug, nil
 8844	})
 8845	if err != nil {
 8846		ec.Error(ctx, err)
 8847		return graphql.Null
 8848	}
 8849	if resTmp == nil {
 8850		if !ec.HasError(rctx) {
 8851			ec.Errorf(ctx, "must not be null")
 8852		}
 8853		return graphql.Null
 8854	}
 8855	res := resTmp.(*bug.Snapshot)
 8856	rctx.Result = res
 8857	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 8858	return ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
 8859}
 8860
 8861func (ec *executionContext) _SetTitlePayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) (ret graphql.Marshaler) {
 8862	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 8863	defer func() {
 8864		if r := recover(); r != nil {
 8865			ec.Error(ctx, ec.Recover(ctx, r))
 8866			ret = graphql.Null
 8867		}
 8868		ec.Tracer.EndFieldExecution(ctx)
 8869	}()
 8870	rctx := &graphql.ResolverContext{
 8871		Object:   "SetTitlePayload",
 8872		Field:    field,
 8873		Args:     nil,
 8874		IsMethod: false,
 8875	}
 8876	ctx = graphql.WithResolverContext(ctx, rctx)
 8877	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 8878	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8879		ctx = rctx // use context from middleware stack in children
 8880		return obj.Operation, nil
 8881	})
 8882	if err != nil {
 8883		ec.Error(ctx, err)
 8884		return graphql.Null
 8885	}
 8886	if resTmp == nil {
 8887		if !ec.HasError(rctx) {
 8888			ec.Errorf(ctx, "must not be null")
 8889		}
 8890		return graphql.Null
 8891	}
 8892	res := resTmp.(*bug.SetTitleOperation)
 8893	rctx.Result = res
 8894	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 8895	return ec.marshalNSetTitleOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetTitleOperation(ctx, field.Selections, res)
 8896}
 8897
 8898func (ec *executionContext) _SetTitleTimelineItem_hash(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
 8899	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 8900	defer func() {
 8901		if r := recover(); r != nil {
 8902			ec.Error(ctx, ec.Recover(ctx, r))
 8903			ret = graphql.Null
 8904		}
 8905		ec.Tracer.EndFieldExecution(ctx)
 8906	}()
 8907	rctx := &graphql.ResolverContext{
 8908		Object:   "SetTitleTimelineItem",
 8909		Field:    field,
 8910		Args:     nil,
 8911		IsMethod: true,
 8912	}
 8913	ctx = graphql.WithResolverContext(ctx, rctx)
 8914	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 8915	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8916		ctx = rctx // use context from middleware stack in children
 8917		return obj.Hash(), nil
 8918	})
 8919	if err != nil {
 8920		ec.Error(ctx, err)
 8921		return graphql.Null
 8922	}
 8923	if resTmp == nil {
 8924		if !ec.HasError(rctx) {
 8925			ec.Errorf(ctx, "must not be null")
 8926		}
 8927		return graphql.Null
 8928	}
 8929	res := resTmp.(git.Hash)
 8930	rctx.Result = res
 8931	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 8932	return ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
 8933}
 8934
 8935func (ec *executionContext) _SetTitleTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
 8936	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 8937	defer func() {
 8938		if r := recover(); r != nil {
 8939			ec.Error(ctx, ec.Recover(ctx, r))
 8940			ret = graphql.Null
 8941		}
 8942		ec.Tracer.EndFieldExecution(ctx)
 8943	}()
 8944	rctx := &graphql.ResolverContext{
 8945		Object:   "SetTitleTimelineItem",
 8946		Field:    field,
 8947		Args:     nil,
 8948		IsMethod: false,
 8949	}
 8950	ctx = graphql.WithResolverContext(ctx, rctx)
 8951	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 8952	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8953		ctx = rctx // use context from middleware stack in children
 8954		return obj.Author, nil
 8955	})
 8956	if err != nil {
 8957		ec.Error(ctx, err)
 8958		return graphql.Null
 8959	}
 8960	if resTmp == nil {
 8961		if !ec.HasError(rctx) {
 8962			ec.Errorf(ctx, "must not be null")
 8963		}
 8964		return graphql.Null
 8965	}
 8966	res := resTmp.(identity.Interface)
 8967	rctx.Result = res
 8968	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 8969	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
 8970}
 8971
 8972func (ec *executionContext) _SetTitleTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
 8973	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 8974	defer func() {
 8975		if r := recover(); r != nil {
 8976			ec.Error(ctx, ec.Recover(ctx, r))
 8977			ret = graphql.Null
 8978		}
 8979		ec.Tracer.EndFieldExecution(ctx)
 8980	}()
 8981	rctx := &graphql.ResolverContext{
 8982		Object:   "SetTitleTimelineItem",
 8983		Field:    field,
 8984		Args:     nil,
 8985		IsMethod: true,
 8986	}
 8987	ctx = graphql.WithResolverContext(ctx, rctx)
 8988	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 8989	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 8990		ctx = rctx // use context from middleware stack in children
 8991		return ec.resolvers.SetTitleTimelineItem().Date(rctx, obj)
 8992	})
 8993	if err != nil {
 8994		ec.Error(ctx, err)
 8995		return graphql.Null
 8996	}
 8997	if resTmp == nil {
 8998		if !ec.HasError(rctx) {
 8999			ec.Errorf(ctx, "must not be null")
 9000		}
 9001		return graphql.Null
 9002	}
 9003	res := resTmp.(*time.Time)
 9004	rctx.Result = res
 9005	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 9006	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 9007}
 9008
 9009func (ec *executionContext) _SetTitleTimelineItem_title(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
 9010	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 9011	defer func() {
 9012		if r := recover(); r != nil {
 9013			ec.Error(ctx, ec.Recover(ctx, r))
 9014			ret = graphql.Null
 9015		}
 9016		ec.Tracer.EndFieldExecution(ctx)
 9017	}()
 9018	rctx := &graphql.ResolverContext{
 9019		Object:   "SetTitleTimelineItem",
 9020		Field:    field,
 9021		Args:     nil,
 9022		IsMethod: false,
 9023	}
 9024	ctx = graphql.WithResolverContext(ctx, rctx)
 9025	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 9026	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9027		ctx = rctx // use context from middleware stack in children
 9028		return obj.Title, nil
 9029	})
 9030	if err != nil {
 9031		ec.Error(ctx, err)
 9032		return graphql.Null
 9033	}
 9034	if resTmp == nil {
 9035		if !ec.HasError(rctx) {
 9036			ec.Errorf(ctx, "must not be null")
 9037		}
 9038		return graphql.Null
 9039	}
 9040	res := resTmp.(string)
 9041	rctx.Result = res
 9042	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 9043	return ec.marshalNString2string(ctx, field.Selections, res)
 9044}
 9045
 9046func (ec *executionContext) _SetTitleTimelineItem_was(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) (ret graphql.Marshaler) {
 9047	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 9048	defer func() {
 9049		if r := recover(); r != nil {
 9050			ec.Error(ctx, ec.Recover(ctx, r))
 9051			ret = graphql.Null
 9052		}
 9053		ec.Tracer.EndFieldExecution(ctx)
 9054	}()
 9055	rctx := &graphql.ResolverContext{
 9056		Object:   "SetTitleTimelineItem",
 9057		Field:    field,
 9058		Args:     nil,
 9059		IsMethod: false,
 9060	}
 9061	ctx = graphql.WithResolverContext(ctx, rctx)
 9062	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 9063	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9064		ctx = rctx // use context from middleware stack in children
 9065		return obj.Was, nil
 9066	})
 9067	if err != nil {
 9068		ec.Error(ctx, err)
 9069		return graphql.Null
 9070	}
 9071	if resTmp == nil {
 9072		if !ec.HasError(rctx) {
 9073			ec.Errorf(ctx, "must not be null")
 9074		}
 9075		return graphql.Null
 9076	}
 9077	res := resTmp.(string)
 9078	rctx.Result = res
 9079	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 9080	return ec.marshalNString2string(ctx, field.Selections, res)
 9081}
 9082
 9083func (ec *executionContext) _TimelineItemConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
 9084	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 9085	defer func() {
 9086		if r := recover(); r != nil {
 9087			ec.Error(ctx, ec.Recover(ctx, r))
 9088			ret = graphql.Null
 9089		}
 9090		ec.Tracer.EndFieldExecution(ctx)
 9091	}()
 9092	rctx := &graphql.ResolverContext{
 9093		Object:   "TimelineItemConnection",
 9094		Field:    field,
 9095		Args:     nil,
 9096		IsMethod: false,
 9097	}
 9098	ctx = graphql.WithResolverContext(ctx, rctx)
 9099	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 9100	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9101		ctx = rctx // use context from middleware stack in children
 9102		return obj.Edges, nil
 9103	})
 9104	if err != nil {
 9105		ec.Error(ctx, err)
 9106		return graphql.Null
 9107	}
 9108	if resTmp == nil {
 9109		if !ec.HasError(rctx) {
 9110			ec.Errorf(ctx, "must not be null")
 9111		}
 9112		return graphql.Null
 9113	}
 9114	res := resTmp.([]*models.TimelineItemEdge)
 9115	rctx.Result = res
 9116	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 9117	return ec.marshalNTimelineItemEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx, field.Selections, res)
 9118}
 9119
 9120func (ec *executionContext) _TimelineItemConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
 9121	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 9122	defer func() {
 9123		if r := recover(); r != nil {
 9124			ec.Error(ctx, ec.Recover(ctx, r))
 9125			ret = graphql.Null
 9126		}
 9127		ec.Tracer.EndFieldExecution(ctx)
 9128	}()
 9129	rctx := &graphql.ResolverContext{
 9130		Object:   "TimelineItemConnection",
 9131		Field:    field,
 9132		Args:     nil,
 9133		IsMethod: false,
 9134	}
 9135	ctx = graphql.WithResolverContext(ctx, rctx)
 9136	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 9137	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9138		ctx = rctx // use context from middleware stack in children
 9139		return obj.Nodes, nil
 9140	})
 9141	if err != nil {
 9142		ec.Error(ctx, err)
 9143		return graphql.Null
 9144	}
 9145	if resTmp == nil {
 9146		if !ec.HasError(rctx) {
 9147			ec.Errorf(ctx, "must not be null")
 9148		}
 9149		return graphql.Null
 9150	}
 9151	res := resTmp.([]bug.TimelineItem)
 9152	rctx.Result = res
 9153	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 9154	return ec.marshalNTimelineItem2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx, field.Selections, res)
 9155}
 9156
 9157func (ec *executionContext) _TimelineItemConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
 9158	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 9159	defer func() {
 9160		if r := recover(); r != nil {
 9161			ec.Error(ctx, ec.Recover(ctx, r))
 9162			ret = graphql.Null
 9163		}
 9164		ec.Tracer.EndFieldExecution(ctx)
 9165	}()
 9166	rctx := &graphql.ResolverContext{
 9167		Object:   "TimelineItemConnection",
 9168		Field:    field,
 9169		Args:     nil,
 9170		IsMethod: false,
 9171	}
 9172	ctx = graphql.WithResolverContext(ctx, rctx)
 9173	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 9174	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9175		ctx = rctx // use context from middleware stack in children
 9176		return obj.PageInfo, nil
 9177	})
 9178	if err != nil {
 9179		ec.Error(ctx, err)
 9180		return graphql.Null
 9181	}
 9182	if resTmp == nil {
 9183		if !ec.HasError(rctx) {
 9184			ec.Errorf(ctx, "must not be null")
 9185		}
 9186		return graphql.Null
 9187	}
 9188	res := resTmp.(*models.PageInfo)
 9189	rctx.Result = res
 9190	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 9191	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
 9192}
 9193
 9194func (ec *executionContext) _TimelineItemConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) (ret graphql.Marshaler) {
 9195	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 9196	defer func() {
 9197		if r := recover(); r != nil {
 9198			ec.Error(ctx, ec.Recover(ctx, r))
 9199			ret = graphql.Null
 9200		}
 9201		ec.Tracer.EndFieldExecution(ctx)
 9202	}()
 9203	rctx := &graphql.ResolverContext{
 9204		Object:   "TimelineItemConnection",
 9205		Field:    field,
 9206		Args:     nil,
 9207		IsMethod: false,
 9208	}
 9209	ctx = graphql.WithResolverContext(ctx, rctx)
 9210	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 9211	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9212		ctx = rctx // use context from middleware stack in children
 9213		return obj.TotalCount, nil
 9214	})
 9215	if err != nil {
 9216		ec.Error(ctx, err)
 9217		return graphql.Null
 9218	}
 9219	if resTmp == nil {
 9220		if !ec.HasError(rctx) {
 9221			ec.Errorf(ctx, "must not be null")
 9222		}
 9223		return graphql.Null
 9224	}
 9225	res := resTmp.(int)
 9226	rctx.Result = res
 9227	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 9228	return ec.marshalNInt2int(ctx, field.Selections, res)
 9229}
 9230
 9231func (ec *executionContext) _TimelineItemEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemEdge) (ret graphql.Marshaler) {
 9232	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 9233	defer func() {
 9234		if r := recover(); r != nil {
 9235			ec.Error(ctx, ec.Recover(ctx, r))
 9236			ret = graphql.Null
 9237		}
 9238		ec.Tracer.EndFieldExecution(ctx)
 9239	}()
 9240	rctx := &graphql.ResolverContext{
 9241		Object:   "TimelineItemEdge",
 9242		Field:    field,
 9243		Args:     nil,
 9244		IsMethod: false,
 9245	}
 9246	ctx = graphql.WithResolverContext(ctx, rctx)
 9247	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 9248	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9249		ctx = rctx // use context from middleware stack in children
 9250		return obj.Cursor, nil
 9251	})
 9252	if err != nil {
 9253		ec.Error(ctx, err)
 9254		return graphql.Null
 9255	}
 9256	if resTmp == nil {
 9257		if !ec.HasError(rctx) {
 9258			ec.Errorf(ctx, "must not be null")
 9259		}
 9260		return graphql.Null
 9261	}
 9262	res := resTmp.(string)
 9263	rctx.Result = res
 9264	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 9265	return ec.marshalNString2string(ctx, field.Selections, res)
 9266}
 9267
 9268func (ec *executionContext) _TimelineItemEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemEdge) (ret graphql.Marshaler) {
 9269	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 9270	defer func() {
 9271		if r := recover(); r != nil {
 9272			ec.Error(ctx, ec.Recover(ctx, r))
 9273			ret = graphql.Null
 9274		}
 9275		ec.Tracer.EndFieldExecution(ctx)
 9276	}()
 9277	rctx := &graphql.ResolverContext{
 9278		Object:   "TimelineItemEdge",
 9279		Field:    field,
 9280		Args:     nil,
 9281		IsMethod: false,
 9282	}
 9283	ctx = graphql.WithResolverContext(ctx, rctx)
 9284	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 9285	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9286		ctx = rctx // use context from middleware stack in children
 9287		return obj.Node, nil
 9288	})
 9289	if err != nil {
 9290		ec.Error(ctx, err)
 9291		return graphql.Null
 9292	}
 9293	if resTmp == nil {
 9294		if !ec.HasError(rctx) {
 9295			ec.Errorf(ctx, "must not be null")
 9296		}
 9297		return graphql.Null
 9298	}
 9299	res := resTmp.(bug.TimelineItem)
 9300	rctx.Result = res
 9301	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 9302	return ec.marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx, field.Selections, res)
 9303}
 9304
 9305func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
 9306	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 9307	defer func() {
 9308		if r := recover(); r != nil {
 9309			ec.Error(ctx, ec.Recover(ctx, r))
 9310			ret = graphql.Null
 9311		}
 9312		ec.Tracer.EndFieldExecution(ctx)
 9313	}()
 9314	rctx := &graphql.ResolverContext{
 9315		Object:   "__Directive",
 9316		Field:    field,
 9317		Args:     nil,
 9318		IsMethod: false,
 9319	}
 9320	ctx = graphql.WithResolverContext(ctx, rctx)
 9321	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 9322	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9323		ctx = rctx // use context from middleware stack in children
 9324		return obj.Name, nil
 9325	})
 9326	if err != nil {
 9327		ec.Error(ctx, err)
 9328		return graphql.Null
 9329	}
 9330	if resTmp == nil {
 9331		if !ec.HasError(rctx) {
 9332			ec.Errorf(ctx, "must not be null")
 9333		}
 9334		return graphql.Null
 9335	}
 9336	res := resTmp.(string)
 9337	rctx.Result = res
 9338	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 9339	return ec.marshalNString2string(ctx, field.Selections, res)
 9340}
 9341
 9342func (ec *executionContext) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
 9343	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 9344	defer func() {
 9345		if r := recover(); r != nil {
 9346			ec.Error(ctx, ec.Recover(ctx, r))
 9347			ret = graphql.Null
 9348		}
 9349		ec.Tracer.EndFieldExecution(ctx)
 9350	}()
 9351	rctx := &graphql.ResolverContext{
 9352		Object:   "__Directive",
 9353		Field:    field,
 9354		Args:     nil,
 9355		IsMethod: false,
 9356	}
 9357	ctx = graphql.WithResolverContext(ctx, rctx)
 9358	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 9359	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9360		ctx = rctx // use context from middleware stack in children
 9361		return obj.Description, nil
 9362	})
 9363	if err != nil {
 9364		ec.Error(ctx, err)
 9365		return graphql.Null
 9366	}
 9367	if resTmp == nil {
 9368		return graphql.Null
 9369	}
 9370	res := resTmp.(string)
 9371	rctx.Result = res
 9372	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 9373	return ec.marshalOString2string(ctx, field.Selections, res)
 9374}
 9375
 9376func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
 9377	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 9378	defer func() {
 9379		if r := recover(); r != nil {
 9380			ec.Error(ctx, ec.Recover(ctx, r))
 9381			ret = graphql.Null
 9382		}
 9383		ec.Tracer.EndFieldExecution(ctx)
 9384	}()
 9385	rctx := &graphql.ResolverContext{
 9386		Object:   "__Directive",
 9387		Field:    field,
 9388		Args:     nil,
 9389		IsMethod: false,
 9390	}
 9391	ctx = graphql.WithResolverContext(ctx, rctx)
 9392	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 9393	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9394		ctx = rctx // use context from middleware stack in children
 9395		return obj.Locations, nil
 9396	})
 9397	if err != nil {
 9398		ec.Error(ctx, err)
 9399		return graphql.Null
 9400	}
 9401	if resTmp == nil {
 9402		if !ec.HasError(rctx) {
 9403			ec.Errorf(ctx, "must not be null")
 9404		}
 9405		return graphql.Null
 9406	}
 9407	res := resTmp.([]string)
 9408	rctx.Result = res
 9409	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 9410	return ec.marshalN__DirectiveLocation2ᚕstring(ctx, field.Selections, res)
 9411}
 9412
 9413func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
 9414	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 9415	defer func() {
 9416		if r := recover(); r != nil {
 9417			ec.Error(ctx, ec.Recover(ctx, r))
 9418			ret = graphql.Null
 9419		}
 9420		ec.Tracer.EndFieldExecution(ctx)
 9421	}()
 9422	rctx := &graphql.ResolverContext{
 9423		Object:   "__Directive",
 9424		Field:    field,
 9425		Args:     nil,
 9426		IsMethod: false,
 9427	}
 9428	ctx = graphql.WithResolverContext(ctx, rctx)
 9429	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 9430	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9431		ctx = rctx // use context from middleware stack in children
 9432		return obj.Args, nil
 9433	})
 9434	if err != nil {
 9435		ec.Error(ctx, err)
 9436		return graphql.Null
 9437	}
 9438	if resTmp == nil {
 9439		if !ec.HasError(rctx) {
 9440			ec.Errorf(ctx, "must not be null")
 9441		}
 9442		return graphql.Null
 9443	}
 9444	res := resTmp.([]introspection.InputValue)
 9445	rctx.Result = res
 9446	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 9447	return ec.marshalN__InputValue2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, field.Selections, res)
 9448}
 9449
 9450func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
 9451	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 9452	defer func() {
 9453		if r := recover(); r != nil {
 9454			ec.Error(ctx, ec.Recover(ctx, r))
 9455			ret = graphql.Null
 9456		}
 9457		ec.Tracer.EndFieldExecution(ctx)
 9458	}()
 9459	rctx := &graphql.ResolverContext{
 9460		Object:   "__EnumValue",
 9461		Field:    field,
 9462		Args:     nil,
 9463		IsMethod: false,
 9464	}
 9465	ctx = graphql.WithResolverContext(ctx, rctx)
 9466	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 9467	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9468		ctx = rctx // use context from middleware stack in children
 9469		return obj.Name, nil
 9470	})
 9471	if err != nil {
 9472		ec.Error(ctx, err)
 9473		return graphql.Null
 9474	}
 9475	if resTmp == nil {
 9476		if !ec.HasError(rctx) {
 9477			ec.Errorf(ctx, "must not be null")
 9478		}
 9479		return graphql.Null
 9480	}
 9481	res := resTmp.(string)
 9482	rctx.Result = res
 9483	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 9484	return ec.marshalNString2string(ctx, field.Selections, res)
 9485}
 9486
 9487func (ec *executionContext) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
 9488	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 9489	defer func() {
 9490		if r := recover(); r != nil {
 9491			ec.Error(ctx, ec.Recover(ctx, r))
 9492			ret = graphql.Null
 9493		}
 9494		ec.Tracer.EndFieldExecution(ctx)
 9495	}()
 9496	rctx := &graphql.ResolverContext{
 9497		Object:   "__EnumValue",
 9498		Field:    field,
 9499		Args:     nil,
 9500		IsMethod: false,
 9501	}
 9502	ctx = graphql.WithResolverContext(ctx, rctx)
 9503	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 9504	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9505		ctx = rctx // use context from middleware stack in children
 9506		return obj.Description, nil
 9507	})
 9508	if err != nil {
 9509		ec.Error(ctx, err)
 9510		return graphql.Null
 9511	}
 9512	if resTmp == nil {
 9513		return graphql.Null
 9514	}
 9515	res := resTmp.(string)
 9516	rctx.Result = res
 9517	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 9518	return ec.marshalOString2string(ctx, field.Selections, res)
 9519}
 9520
 9521func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
 9522	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 9523	defer func() {
 9524		if r := recover(); r != nil {
 9525			ec.Error(ctx, ec.Recover(ctx, r))
 9526			ret = graphql.Null
 9527		}
 9528		ec.Tracer.EndFieldExecution(ctx)
 9529	}()
 9530	rctx := &graphql.ResolverContext{
 9531		Object:   "__EnumValue",
 9532		Field:    field,
 9533		Args:     nil,
 9534		IsMethod: true,
 9535	}
 9536	ctx = graphql.WithResolverContext(ctx, rctx)
 9537	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 9538	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9539		ctx = rctx // use context from middleware stack in children
 9540		return obj.IsDeprecated(), nil
 9541	})
 9542	if err != nil {
 9543		ec.Error(ctx, err)
 9544		return graphql.Null
 9545	}
 9546	if resTmp == nil {
 9547		if !ec.HasError(rctx) {
 9548			ec.Errorf(ctx, "must not be null")
 9549		}
 9550		return graphql.Null
 9551	}
 9552	res := resTmp.(bool)
 9553	rctx.Result = res
 9554	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 9555	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 9556}
 9557
 9558func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
 9559	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 9560	defer func() {
 9561		if r := recover(); r != nil {
 9562			ec.Error(ctx, ec.Recover(ctx, r))
 9563			ret = graphql.Null
 9564		}
 9565		ec.Tracer.EndFieldExecution(ctx)
 9566	}()
 9567	rctx := &graphql.ResolverContext{
 9568		Object:   "__EnumValue",
 9569		Field:    field,
 9570		Args:     nil,
 9571		IsMethod: true,
 9572	}
 9573	ctx = graphql.WithResolverContext(ctx, rctx)
 9574	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 9575	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9576		ctx = rctx // use context from middleware stack in children
 9577		return obj.DeprecationReason(), nil
 9578	})
 9579	if err != nil {
 9580		ec.Error(ctx, err)
 9581		return graphql.Null
 9582	}
 9583	if resTmp == nil {
 9584		return graphql.Null
 9585	}
 9586	res := resTmp.(*string)
 9587	rctx.Result = res
 9588	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 9589	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 9590}
 9591
 9592func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
 9593	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 9594	defer func() {
 9595		if r := recover(); r != nil {
 9596			ec.Error(ctx, ec.Recover(ctx, r))
 9597			ret = graphql.Null
 9598		}
 9599		ec.Tracer.EndFieldExecution(ctx)
 9600	}()
 9601	rctx := &graphql.ResolverContext{
 9602		Object:   "__Field",
 9603		Field:    field,
 9604		Args:     nil,
 9605		IsMethod: false,
 9606	}
 9607	ctx = graphql.WithResolverContext(ctx, rctx)
 9608	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 9609	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9610		ctx = rctx // use context from middleware stack in children
 9611		return obj.Name, nil
 9612	})
 9613	if err != nil {
 9614		ec.Error(ctx, err)
 9615		return graphql.Null
 9616	}
 9617	if resTmp == nil {
 9618		if !ec.HasError(rctx) {
 9619			ec.Errorf(ctx, "must not be null")
 9620		}
 9621		return graphql.Null
 9622	}
 9623	res := resTmp.(string)
 9624	rctx.Result = res
 9625	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 9626	return ec.marshalNString2string(ctx, field.Selections, res)
 9627}
 9628
 9629func (ec *executionContext) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
 9630	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 9631	defer func() {
 9632		if r := recover(); r != nil {
 9633			ec.Error(ctx, ec.Recover(ctx, r))
 9634			ret = graphql.Null
 9635		}
 9636		ec.Tracer.EndFieldExecution(ctx)
 9637	}()
 9638	rctx := &graphql.ResolverContext{
 9639		Object:   "__Field",
 9640		Field:    field,
 9641		Args:     nil,
 9642		IsMethod: false,
 9643	}
 9644	ctx = graphql.WithResolverContext(ctx, rctx)
 9645	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 9646	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9647		ctx = rctx // use context from middleware stack in children
 9648		return obj.Description, nil
 9649	})
 9650	if err != nil {
 9651		ec.Error(ctx, err)
 9652		return graphql.Null
 9653	}
 9654	if resTmp == nil {
 9655		return graphql.Null
 9656	}
 9657	res := resTmp.(string)
 9658	rctx.Result = res
 9659	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 9660	return ec.marshalOString2string(ctx, field.Selections, res)
 9661}
 9662
 9663func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
 9664	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 9665	defer func() {
 9666		if r := recover(); r != nil {
 9667			ec.Error(ctx, ec.Recover(ctx, r))
 9668			ret = graphql.Null
 9669		}
 9670		ec.Tracer.EndFieldExecution(ctx)
 9671	}()
 9672	rctx := &graphql.ResolverContext{
 9673		Object:   "__Field",
 9674		Field:    field,
 9675		Args:     nil,
 9676		IsMethod: false,
 9677	}
 9678	ctx = graphql.WithResolverContext(ctx, rctx)
 9679	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 9680	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9681		ctx = rctx // use context from middleware stack in children
 9682		return obj.Args, nil
 9683	})
 9684	if err != nil {
 9685		ec.Error(ctx, err)
 9686		return graphql.Null
 9687	}
 9688	if resTmp == nil {
 9689		if !ec.HasError(rctx) {
 9690			ec.Errorf(ctx, "must not be null")
 9691		}
 9692		return graphql.Null
 9693	}
 9694	res := resTmp.([]introspection.InputValue)
 9695	rctx.Result = res
 9696	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 9697	return ec.marshalN__InputValue2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, field.Selections, res)
 9698}
 9699
 9700func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
 9701	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 9702	defer func() {
 9703		if r := recover(); r != nil {
 9704			ec.Error(ctx, ec.Recover(ctx, r))
 9705			ret = graphql.Null
 9706		}
 9707		ec.Tracer.EndFieldExecution(ctx)
 9708	}()
 9709	rctx := &graphql.ResolverContext{
 9710		Object:   "__Field",
 9711		Field:    field,
 9712		Args:     nil,
 9713		IsMethod: false,
 9714	}
 9715	ctx = graphql.WithResolverContext(ctx, rctx)
 9716	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 9717	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9718		ctx = rctx // use context from middleware stack in children
 9719		return obj.Type, nil
 9720	})
 9721	if err != nil {
 9722		ec.Error(ctx, err)
 9723		return graphql.Null
 9724	}
 9725	if resTmp == nil {
 9726		if !ec.HasError(rctx) {
 9727			ec.Errorf(ctx, "must not be null")
 9728		}
 9729		return graphql.Null
 9730	}
 9731	res := resTmp.(*introspection.Type)
 9732	rctx.Result = res
 9733	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 9734	return ec.marshalN__Type2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
 9735}
 9736
 9737func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
 9738	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 9739	defer func() {
 9740		if r := recover(); r != nil {
 9741			ec.Error(ctx, ec.Recover(ctx, r))
 9742			ret = graphql.Null
 9743		}
 9744		ec.Tracer.EndFieldExecution(ctx)
 9745	}()
 9746	rctx := &graphql.ResolverContext{
 9747		Object:   "__Field",
 9748		Field:    field,
 9749		Args:     nil,
 9750		IsMethod: true,
 9751	}
 9752	ctx = graphql.WithResolverContext(ctx, rctx)
 9753	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 9754	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9755		ctx = rctx // use context from middleware stack in children
 9756		return obj.IsDeprecated(), nil
 9757	})
 9758	if err != nil {
 9759		ec.Error(ctx, err)
 9760		return graphql.Null
 9761	}
 9762	if resTmp == nil {
 9763		if !ec.HasError(rctx) {
 9764			ec.Errorf(ctx, "must not be null")
 9765		}
 9766		return graphql.Null
 9767	}
 9768	res := resTmp.(bool)
 9769	rctx.Result = res
 9770	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 9771	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 9772}
 9773
 9774func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
 9775	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 9776	defer func() {
 9777		if r := recover(); r != nil {
 9778			ec.Error(ctx, ec.Recover(ctx, r))
 9779			ret = graphql.Null
 9780		}
 9781		ec.Tracer.EndFieldExecution(ctx)
 9782	}()
 9783	rctx := &graphql.ResolverContext{
 9784		Object:   "__Field",
 9785		Field:    field,
 9786		Args:     nil,
 9787		IsMethod: true,
 9788	}
 9789	ctx = graphql.WithResolverContext(ctx, rctx)
 9790	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 9791	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9792		ctx = rctx // use context from middleware stack in children
 9793		return obj.DeprecationReason(), nil
 9794	})
 9795	if err != nil {
 9796		ec.Error(ctx, err)
 9797		return graphql.Null
 9798	}
 9799	if resTmp == nil {
 9800		return graphql.Null
 9801	}
 9802	res := resTmp.(*string)
 9803	rctx.Result = res
 9804	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 9805	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 9806}
 9807
 9808func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
 9809	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 9810	defer func() {
 9811		if r := recover(); r != nil {
 9812			ec.Error(ctx, ec.Recover(ctx, r))
 9813			ret = graphql.Null
 9814		}
 9815		ec.Tracer.EndFieldExecution(ctx)
 9816	}()
 9817	rctx := &graphql.ResolverContext{
 9818		Object:   "__InputValue",
 9819		Field:    field,
 9820		Args:     nil,
 9821		IsMethod: false,
 9822	}
 9823	ctx = graphql.WithResolverContext(ctx, rctx)
 9824	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 9825	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9826		ctx = rctx // use context from middleware stack in children
 9827		return obj.Name, nil
 9828	})
 9829	if err != nil {
 9830		ec.Error(ctx, err)
 9831		return graphql.Null
 9832	}
 9833	if resTmp == nil {
 9834		if !ec.HasError(rctx) {
 9835			ec.Errorf(ctx, "must not be null")
 9836		}
 9837		return graphql.Null
 9838	}
 9839	res := resTmp.(string)
 9840	rctx.Result = res
 9841	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 9842	return ec.marshalNString2string(ctx, field.Selections, res)
 9843}
 9844
 9845func (ec *executionContext) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
 9846	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 9847	defer func() {
 9848		if r := recover(); r != nil {
 9849			ec.Error(ctx, ec.Recover(ctx, r))
 9850			ret = graphql.Null
 9851		}
 9852		ec.Tracer.EndFieldExecution(ctx)
 9853	}()
 9854	rctx := &graphql.ResolverContext{
 9855		Object:   "__InputValue",
 9856		Field:    field,
 9857		Args:     nil,
 9858		IsMethod: false,
 9859	}
 9860	ctx = graphql.WithResolverContext(ctx, rctx)
 9861	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 9862	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9863		ctx = rctx // use context from middleware stack in children
 9864		return obj.Description, nil
 9865	})
 9866	if err != nil {
 9867		ec.Error(ctx, err)
 9868		return graphql.Null
 9869	}
 9870	if resTmp == nil {
 9871		return graphql.Null
 9872	}
 9873	res := resTmp.(string)
 9874	rctx.Result = res
 9875	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 9876	return ec.marshalOString2string(ctx, field.Selections, res)
 9877}
 9878
 9879func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
 9880	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 9881	defer func() {
 9882		if r := recover(); r != nil {
 9883			ec.Error(ctx, ec.Recover(ctx, r))
 9884			ret = graphql.Null
 9885		}
 9886		ec.Tracer.EndFieldExecution(ctx)
 9887	}()
 9888	rctx := &graphql.ResolverContext{
 9889		Object:   "__InputValue",
 9890		Field:    field,
 9891		Args:     nil,
 9892		IsMethod: false,
 9893	}
 9894	ctx = graphql.WithResolverContext(ctx, rctx)
 9895	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 9896	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9897		ctx = rctx // use context from middleware stack in children
 9898		return obj.Type, nil
 9899	})
 9900	if err != nil {
 9901		ec.Error(ctx, err)
 9902		return graphql.Null
 9903	}
 9904	if resTmp == nil {
 9905		if !ec.HasError(rctx) {
 9906			ec.Errorf(ctx, "must not be null")
 9907		}
 9908		return graphql.Null
 9909	}
 9910	res := resTmp.(*introspection.Type)
 9911	rctx.Result = res
 9912	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 9913	return ec.marshalN__Type2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
 9914}
 9915
 9916func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
 9917	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 9918	defer func() {
 9919		if r := recover(); r != nil {
 9920			ec.Error(ctx, ec.Recover(ctx, r))
 9921			ret = graphql.Null
 9922		}
 9923		ec.Tracer.EndFieldExecution(ctx)
 9924	}()
 9925	rctx := &graphql.ResolverContext{
 9926		Object:   "__InputValue",
 9927		Field:    field,
 9928		Args:     nil,
 9929		IsMethod: false,
 9930	}
 9931	ctx = graphql.WithResolverContext(ctx, rctx)
 9932	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 9933	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9934		ctx = rctx // use context from middleware stack in children
 9935		return obj.DefaultValue, nil
 9936	})
 9937	if err != nil {
 9938		ec.Error(ctx, err)
 9939		return graphql.Null
 9940	}
 9941	if resTmp == nil {
 9942		return graphql.Null
 9943	}
 9944	res := resTmp.(*string)
 9945	rctx.Result = res
 9946	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 9947	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 9948}
 9949
 9950func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
 9951	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 9952	defer func() {
 9953		if r := recover(); r != nil {
 9954			ec.Error(ctx, ec.Recover(ctx, r))
 9955			ret = graphql.Null
 9956		}
 9957		ec.Tracer.EndFieldExecution(ctx)
 9958	}()
 9959	rctx := &graphql.ResolverContext{
 9960		Object:   "__Schema",
 9961		Field:    field,
 9962		Args:     nil,
 9963		IsMethod: true,
 9964	}
 9965	ctx = graphql.WithResolverContext(ctx, rctx)
 9966	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 9967	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
 9968		ctx = rctx // use context from middleware stack in children
 9969		return obj.Types(), nil
 9970	})
 9971	if err != nil {
 9972		ec.Error(ctx, err)
 9973		return graphql.Null
 9974	}
 9975	if resTmp == nil {
 9976		if !ec.HasError(rctx) {
 9977			ec.Errorf(ctx, "must not be null")
 9978		}
 9979		return graphql.Null
 9980	}
 9981	res := resTmp.([]introspection.Type)
 9982	rctx.Result = res
 9983	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 9984	return ec.marshalN__Type2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
 9985}
 9986
 9987func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
 9988	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 9989	defer func() {
 9990		if r := recover(); r != nil {
 9991			ec.Error(ctx, ec.Recover(ctx, r))
 9992			ret = graphql.Null
 9993		}
 9994		ec.Tracer.EndFieldExecution(ctx)
 9995	}()
 9996	rctx := &graphql.ResolverContext{
 9997		Object:   "__Schema",
 9998		Field:    field,
 9999		Args:     nil,
10000		IsMethod: true,
10001	}
10002	ctx = graphql.WithResolverContext(ctx, rctx)
10003	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
10004	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10005		ctx = rctx // use context from middleware stack in children
10006		return obj.QueryType(), nil
10007	})
10008	if err != nil {
10009		ec.Error(ctx, err)
10010		return graphql.Null
10011	}
10012	if resTmp == nil {
10013		if !ec.HasError(rctx) {
10014			ec.Errorf(ctx, "must not be null")
10015		}
10016		return graphql.Null
10017	}
10018	res := resTmp.(*introspection.Type)
10019	rctx.Result = res
10020	ctx = ec.Tracer.StartFieldChildExecution(ctx)
10021	return ec.marshalN__Type2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
10022}
10023
10024func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
10025	ctx = ec.Tracer.StartFieldExecution(ctx, field)
10026	defer func() {
10027		if r := recover(); r != nil {
10028			ec.Error(ctx, ec.Recover(ctx, r))
10029			ret = graphql.Null
10030		}
10031		ec.Tracer.EndFieldExecution(ctx)
10032	}()
10033	rctx := &graphql.ResolverContext{
10034		Object:   "__Schema",
10035		Field:    field,
10036		Args:     nil,
10037		IsMethod: true,
10038	}
10039	ctx = graphql.WithResolverContext(ctx, rctx)
10040	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
10041	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10042		ctx = rctx // use context from middleware stack in children
10043		return obj.MutationType(), nil
10044	})
10045	if err != nil {
10046		ec.Error(ctx, err)
10047		return graphql.Null
10048	}
10049	if resTmp == nil {
10050		return graphql.Null
10051	}
10052	res := resTmp.(*introspection.Type)
10053	rctx.Result = res
10054	ctx = ec.Tracer.StartFieldChildExecution(ctx)
10055	return ec.marshalO__Type2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
10056}
10057
10058func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
10059	ctx = ec.Tracer.StartFieldExecution(ctx, field)
10060	defer func() {
10061		if r := recover(); r != nil {
10062			ec.Error(ctx, ec.Recover(ctx, r))
10063			ret = graphql.Null
10064		}
10065		ec.Tracer.EndFieldExecution(ctx)
10066	}()
10067	rctx := &graphql.ResolverContext{
10068		Object:   "__Schema",
10069		Field:    field,
10070		Args:     nil,
10071		IsMethod: true,
10072	}
10073	ctx = graphql.WithResolverContext(ctx, rctx)
10074	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
10075	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10076		ctx = rctx // use context from middleware stack in children
10077		return obj.SubscriptionType(), nil
10078	})
10079	if err != nil {
10080		ec.Error(ctx, err)
10081		return graphql.Null
10082	}
10083	if resTmp == nil {
10084		return graphql.Null
10085	}
10086	res := resTmp.(*introspection.Type)
10087	rctx.Result = res
10088	ctx = ec.Tracer.StartFieldChildExecution(ctx)
10089	return ec.marshalO__Type2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
10090}
10091
10092func (ec *executionContext) ___Schema_directives(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
10093	ctx = ec.Tracer.StartFieldExecution(ctx, field)
10094	defer func() {
10095		if r := recover(); r != nil {
10096			ec.Error(ctx, ec.Recover(ctx, r))
10097			ret = graphql.Null
10098		}
10099		ec.Tracer.EndFieldExecution(ctx)
10100	}()
10101	rctx := &graphql.ResolverContext{
10102		Object:   "__Schema",
10103		Field:    field,
10104		Args:     nil,
10105		IsMethod: true,
10106	}
10107	ctx = graphql.WithResolverContext(ctx, rctx)
10108	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
10109	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10110		ctx = rctx // use context from middleware stack in children
10111		return obj.Directives(), nil
10112	})
10113	if err != nil {
10114		ec.Error(ctx, err)
10115		return graphql.Null
10116	}
10117	if resTmp == nil {
10118		if !ec.HasError(rctx) {
10119			ec.Errorf(ctx, "must not be null")
10120		}
10121		return graphql.Null
10122	}
10123	res := resTmp.([]introspection.Directive)
10124	rctx.Result = res
10125	ctx = ec.Tracer.StartFieldChildExecution(ctx)
10126	return ec.marshalN__Directive2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx, field.Selections, res)
10127}
10128
10129func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10130	ctx = ec.Tracer.StartFieldExecution(ctx, field)
10131	defer func() {
10132		if r := recover(); r != nil {
10133			ec.Error(ctx, ec.Recover(ctx, r))
10134			ret = graphql.Null
10135		}
10136		ec.Tracer.EndFieldExecution(ctx)
10137	}()
10138	rctx := &graphql.ResolverContext{
10139		Object:   "__Type",
10140		Field:    field,
10141		Args:     nil,
10142		IsMethod: true,
10143	}
10144	ctx = graphql.WithResolverContext(ctx, rctx)
10145	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
10146	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10147		ctx = rctx // use context from middleware stack in children
10148		return obj.Kind(), nil
10149	})
10150	if err != nil {
10151		ec.Error(ctx, err)
10152		return graphql.Null
10153	}
10154	if resTmp == nil {
10155		if !ec.HasError(rctx) {
10156			ec.Errorf(ctx, "must not be null")
10157		}
10158		return graphql.Null
10159	}
10160	res := resTmp.(string)
10161	rctx.Result = res
10162	ctx = ec.Tracer.StartFieldChildExecution(ctx)
10163	return ec.marshalN__TypeKind2string(ctx, field.Selections, res)
10164}
10165
10166func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10167	ctx = ec.Tracer.StartFieldExecution(ctx, field)
10168	defer func() {
10169		if r := recover(); r != nil {
10170			ec.Error(ctx, ec.Recover(ctx, r))
10171			ret = graphql.Null
10172		}
10173		ec.Tracer.EndFieldExecution(ctx)
10174	}()
10175	rctx := &graphql.ResolverContext{
10176		Object:   "__Type",
10177		Field:    field,
10178		Args:     nil,
10179		IsMethod: true,
10180	}
10181	ctx = graphql.WithResolverContext(ctx, rctx)
10182	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
10183	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10184		ctx = rctx // use context from middleware stack in children
10185		return obj.Name(), nil
10186	})
10187	if err != nil {
10188		ec.Error(ctx, err)
10189		return graphql.Null
10190	}
10191	if resTmp == nil {
10192		return graphql.Null
10193	}
10194	res := resTmp.(*string)
10195	rctx.Result = res
10196	ctx = ec.Tracer.StartFieldChildExecution(ctx)
10197	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
10198}
10199
10200func (ec *executionContext) ___Type_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10201	ctx = ec.Tracer.StartFieldExecution(ctx, field)
10202	defer func() {
10203		if r := recover(); r != nil {
10204			ec.Error(ctx, ec.Recover(ctx, r))
10205			ret = graphql.Null
10206		}
10207		ec.Tracer.EndFieldExecution(ctx)
10208	}()
10209	rctx := &graphql.ResolverContext{
10210		Object:   "__Type",
10211		Field:    field,
10212		Args:     nil,
10213		IsMethod: true,
10214	}
10215	ctx = graphql.WithResolverContext(ctx, rctx)
10216	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
10217	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10218		ctx = rctx // use context from middleware stack in children
10219		return obj.Description(), nil
10220	})
10221	if err != nil {
10222		ec.Error(ctx, err)
10223		return graphql.Null
10224	}
10225	if resTmp == nil {
10226		return graphql.Null
10227	}
10228	res := resTmp.(string)
10229	rctx.Result = res
10230	ctx = ec.Tracer.StartFieldChildExecution(ctx)
10231	return ec.marshalOString2string(ctx, field.Selections, res)
10232}
10233
10234func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10235	ctx = ec.Tracer.StartFieldExecution(ctx, field)
10236	defer func() {
10237		if r := recover(); r != nil {
10238			ec.Error(ctx, ec.Recover(ctx, r))
10239			ret = graphql.Null
10240		}
10241		ec.Tracer.EndFieldExecution(ctx)
10242	}()
10243	rctx := &graphql.ResolverContext{
10244		Object:   "__Type",
10245		Field:    field,
10246		Args:     nil,
10247		IsMethod: true,
10248	}
10249	ctx = graphql.WithResolverContext(ctx, rctx)
10250	rawArgs := field.ArgumentMap(ec.Variables)
10251	args, err := ec.field___Type_fields_args(ctx, rawArgs)
10252	if err != nil {
10253		ec.Error(ctx, err)
10254		return graphql.Null
10255	}
10256	rctx.Args = args
10257	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
10258	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10259		ctx = rctx // use context from middleware stack in children
10260		return obj.Fields(args["includeDeprecated"].(bool)), nil
10261	})
10262	if err != nil {
10263		ec.Error(ctx, err)
10264		return graphql.Null
10265	}
10266	if resTmp == nil {
10267		return graphql.Null
10268	}
10269	res := resTmp.([]introspection.Field)
10270	rctx.Result = res
10271	ctx = ec.Tracer.StartFieldChildExecution(ctx)
10272	return ec.marshalO__Field2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx, field.Selections, res)
10273}
10274
10275func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10276	ctx = ec.Tracer.StartFieldExecution(ctx, field)
10277	defer func() {
10278		if r := recover(); r != nil {
10279			ec.Error(ctx, ec.Recover(ctx, r))
10280			ret = graphql.Null
10281		}
10282		ec.Tracer.EndFieldExecution(ctx)
10283	}()
10284	rctx := &graphql.ResolverContext{
10285		Object:   "__Type",
10286		Field:    field,
10287		Args:     nil,
10288		IsMethod: true,
10289	}
10290	ctx = graphql.WithResolverContext(ctx, rctx)
10291	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
10292	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10293		ctx = rctx // use context from middleware stack in children
10294		return obj.Interfaces(), nil
10295	})
10296	if err != nil {
10297		ec.Error(ctx, err)
10298		return graphql.Null
10299	}
10300	if resTmp == nil {
10301		return graphql.Null
10302	}
10303	res := resTmp.([]introspection.Type)
10304	rctx.Result = res
10305	ctx = ec.Tracer.StartFieldChildExecution(ctx)
10306	return ec.marshalO__Type2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
10307}
10308
10309func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10310	ctx = ec.Tracer.StartFieldExecution(ctx, field)
10311	defer func() {
10312		if r := recover(); r != nil {
10313			ec.Error(ctx, ec.Recover(ctx, r))
10314			ret = graphql.Null
10315		}
10316		ec.Tracer.EndFieldExecution(ctx)
10317	}()
10318	rctx := &graphql.ResolverContext{
10319		Object:   "__Type",
10320		Field:    field,
10321		Args:     nil,
10322		IsMethod: true,
10323	}
10324	ctx = graphql.WithResolverContext(ctx, rctx)
10325	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
10326	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10327		ctx = rctx // use context from middleware stack in children
10328		return obj.PossibleTypes(), nil
10329	})
10330	if err != nil {
10331		ec.Error(ctx, err)
10332		return graphql.Null
10333	}
10334	if resTmp == nil {
10335		return graphql.Null
10336	}
10337	res := resTmp.([]introspection.Type)
10338	rctx.Result = res
10339	ctx = ec.Tracer.StartFieldChildExecution(ctx)
10340	return ec.marshalO__Type2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
10341}
10342
10343func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10344	ctx = ec.Tracer.StartFieldExecution(ctx, field)
10345	defer func() {
10346		if r := recover(); r != nil {
10347			ec.Error(ctx, ec.Recover(ctx, r))
10348			ret = graphql.Null
10349		}
10350		ec.Tracer.EndFieldExecution(ctx)
10351	}()
10352	rctx := &graphql.ResolverContext{
10353		Object:   "__Type",
10354		Field:    field,
10355		Args:     nil,
10356		IsMethod: true,
10357	}
10358	ctx = graphql.WithResolverContext(ctx, rctx)
10359	rawArgs := field.ArgumentMap(ec.Variables)
10360	args, err := ec.field___Type_enumValues_args(ctx, rawArgs)
10361	if err != nil {
10362		ec.Error(ctx, err)
10363		return graphql.Null
10364	}
10365	rctx.Args = args
10366	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
10367	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10368		ctx = rctx // use context from middleware stack in children
10369		return obj.EnumValues(args["includeDeprecated"].(bool)), nil
10370	})
10371	if err != nil {
10372		ec.Error(ctx, err)
10373		return graphql.Null
10374	}
10375	if resTmp == nil {
10376		return graphql.Null
10377	}
10378	res := resTmp.([]introspection.EnumValue)
10379	rctx.Result = res
10380	ctx = ec.Tracer.StartFieldChildExecution(ctx)
10381	return ec.marshalO__EnumValue2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx, field.Selections, res)
10382}
10383
10384func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10385	ctx = ec.Tracer.StartFieldExecution(ctx, field)
10386	defer func() {
10387		if r := recover(); r != nil {
10388			ec.Error(ctx, ec.Recover(ctx, r))
10389			ret = graphql.Null
10390		}
10391		ec.Tracer.EndFieldExecution(ctx)
10392	}()
10393	rctx := &graphql.ResolverContext{
10394		Object:   "__Type",
10395		Field:    field,
10396		Args:     nil,
10397		IsMethod: true,
10398	}
10399	ctx = graphql.WithResolverContext(ctx, rctx)
10400	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
10401	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10402		ctx = rctx // use context from middleware stack in children
10403		return obj.InputFields(), nil
10404	})
10405	if err != nil {
10406		ec.Error(ctx, err)
10407		return graphql.Null
10408	}
10409	if resTmp == nil {
10410		return graphql.Null
10411	}
10412	res := resTmp.([]introspection.InputValue)
10413	rctx.Result = res
10414	ctx = ec.Tracer.StartFieldChildExecution(ctx)
10415	return ec.marshalO__InputValue2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, field.Selections, res)
10416}
10417
10418func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
10419	ctx = ec.Tracer.StartFieldExecution(ctx, field)
10420	defer func() {
10421		if r := recover(); r != nil {
10422			ec.Error(ctx, ec.Recover(ctx, r))
10423			ret = graphql.Null
10424		}
10425		ec.Tracer.EndFieldExecution(ctx)
10426	}()
10427	rctx := &graphql.ResolverContext{
10428		Object:   "__Type",
10429		Field:    field,
10430		Args:     nil,
10431		IsMethod: true,
10432	}
10433	ctx = graphql.WithResolverContext(ctx, rctx)
10434	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
10435	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
10436		ctx = rctx // use context from middleware stack in children
10437		return obj.OfType(), nil
10438	})
10439	if err != nil {
10440		ec.Error(ctx, err)
10441		return graphql.Null
10442	}
10443	if resTmp == nil {
10444		return graphql.Null
10445	}
10446	res := resTmp.(*introspection.Type)
10447	rctx.Result = res
10448	ctx = ec.Tracer.StartFieldChildExecution(ctx)
10449	return ec.marshalO__Type2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
10450}
10451
10452// endregion **************************** field.gotpl *****************************
10453
10454// region    **************************** input.gotpl *****************************
10455
10456func (ec *executionContext) unmarshalInputAddCommentInput(ctx context.Context, obj interface{}) (models.AddCommentInput, error) {
10457	var it models.AddCommentInput
10458	var asMap = obj.(map[string]interface{})
10459
10460	for k, v := range asMap {
10461		switch k {
10462		case "clientMutationId":
10463			var err error
10464			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10465			if err != nil {
10466				return it, err
10467			}
10468		case "repoRef":
10469			var err error
10470			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10471			if err != nil {
10472				return it, err
10473			}
10474		case "prefix":
10475			var err error
10476			it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10477			if err != nil {
10478				return it, err
10479			}
10480		case "message":
10481			var err error
10482			it.Message, err = ec.unmarshalNString2string(ctx, v)
10483			if err != nil {
10484				return it, err
10485			}
10486		case "files":
10487			var err error
10488			it.Files, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, v)
10489			if err != nil {
10490				return it, err
10491			}
10492		}
10493	}
10494
10495	return it, nil
10496}
10497
10498func (ec *executionContext) unmarshalInputChangeLabelInput(ctx context.Context, obj interface{}) (models.ChangeLabelInput, error) {
10499	var it models.ChangeLabelInput
10500	var asMap = obj.(map[string]interface{})
10501
10502	for k, v := range asMap {
10503		switch k {
10504		case "clientMutationId":
10505			var err error
10506			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10507			if err != nil {
10508				return it, err
10509			}
10510		case "repoRef":
10511			var err error
10512			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10513			if err != nil {
10514				return it, err
10515			}
10516		case "prefix":
10517			var err error
10518			it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10519			if err != nil {
10520				return it, err
10521			}
10522		case "added":
10523			var err error
10524			it.Added, err = ec.unmarshalOString2ᚕstring(ctx, v)
10525			if err != nil {
10526				return it, err
10527			}
10528		case "Removed":
10529			var err error
10530			it.Removed, err = ec.unmarshalOString2ᚕstring(ctx, v)
10531			if err != nil {
10532				return it, err
10533			}
10534		}
10535	}
10536
10537	return it, nil
10538}
10539
10540func (ec *executionContext) unmarshalInputCloseBugInput(ctx context.Context, obj interface{}) (models.CloseBugInput, error) {
10541	var it models.CloseBugInput
10542	var asMap = obj.(map[string]interface{})
10543
10544	for k, v := range asMap {
10545		switch k {
10546		case "clientMutationId":
10547			var err error
10548			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10549			if err != nil {
10550				return it, err
10551			}
10552		case "repoRef":
10553			var err error
10554			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10555			if err != nil {
10556				return it, err
10557			}
10558		case "prefix":
10559			var err error
10560			it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10561			if err != nil {
10562				return it, err
10563			}
10564		}
10565	}
10566
10567	return it, nil
10568}
10569
10570func (ec *executionContext) unmarshalInputCommitAsNeededInput(ctx context.Context, obj interface{}) (models.CommitAsNeededInput, error) {
10571	var it models.CommitAsNeededInput
10572	var asMap = obj.(map[string]interface{})
10573
10574	for k, v := range asMap {
10575		switch k {
10576		case "clientMutationId":
10577			var err error
10578			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10579			if err != nil {
10580				return it, err
10581			}
10582		case "repoRef":
10583			var err error
10584			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10585			if err != nil {
10586				return it, err
10587			}
10588		case "prefix":
10589			var err error
10590			it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10591			if err != nil {
10592				return it, err
10593			}
10594		}
10595	}
10596
10597	return it, nil
10598}
10599
10600func (ec *executionContext) unmarshalInputCommitInput(ctx context.Context, obj interface{}) (models.CommitInput, error) {
10601	var it models.CommitInput
10602	var asMap = obj.(map[string]interface{})
10603
10604	for k, v := range asMap {
10605		switch k {
10606		case "clientMutationId":
10607			var err error
10608			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10609			if err != nil {
10610				return it, err
10611			}
10612		case "repoRef":
10613			var err error
10614			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10615			if err != nil {
10616				return it, err
10617			}
10618		case "prefix":
10619			var err error
10620			it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10621			if err != nil {
10622				return it, err
10623			}
10624		}
10625	}
10626
10627	return it, nil
10628}
10629
10630func (ec *executionContext) unmarshalInputNewBugInput(ctx context.Context, obj interface{}) (models.NewBugInput, error) {
10631	var it models.NewBugInput
10632	var asMap = obj.(map[string]interface{})
10633
10634	for k, v := range asMap {
10635		switch k {
10636		case "clientMutationId":
10637			var err error
10638			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10639			if err != nil {
10640				return it, err
10641			}
10642		case "repoRef":
10643			var err error
10644			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10645			if err != nil {
10646				return it, err
10647			}
10648		case "title":
10649			var err error
10650			it.Title, err = ec.unmarshalNString2string(ctx, v)
10651			if err != nil {
10652				return it, err
10653			}
10654		case "message":
10655			var err error
10656			it.Message, err = ec.unmarshalNString2string(ctx, v)
10657			if err != nil {
10658				return it, err
10659			}
10660		case "files":
10661			var err error
10662			it.Files, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, v)
10663			if err != nil {
10664				return it, err
10665			}
10666		}
10667	}
10668
10669	return it, nil
10670}
10671
10672func (ec *executionContext) unmarshalInputOpenBugInput(ctx context.Context, obj interface{}) (models.OpenBugInput, error) {
10673	var it models.OpenBugInput
10674	var asMap = obj.(map[string]interface{})
10675
10676	for k, v := range asMap {
10677		switch k {
10678		case "clientMutationId":
10679			var err error
10680			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10681			if err != nil {
10682				return it, err
10683			}
10684		case "repoRef":
10685			var err error
10686			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10687			if err != nil {
10688				return it, err
10689			}
10690		case "prefix":
10691			var err error
10692			it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10693			if err != nil {
10694				return it, err
10695			}
10696		}
10697	}
10698
10699	return it, nil
10700}
10701
10702func (ec *executionContext) unmarshalInputSetTitleInput(ctx context.Context, obj interface{}) (models.SetTitleInput, error) {
10703	var it models.SetTitleInput
10704	var asMap = obj.(map[string]interface{})
10705
10706	for k, v := range asMap {
10707		switch k {
10708		case "clientMutationId":
10709			var err error
10710			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
10711			if err != nil {
10712				return it, err
10713			}
10714		case "repoRef":
10715			var err error
10716			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
10717			if err != nil {
10718				return it, err
10719			}
10720		case "prefix":
10721			var err error
10722			it.Prefix, err = ec.unmarshalNString2string(ctx, v)
10723			if err != nil {
10724				return it, err
10725			}
10726		case "title":
10727			var err error
10728			it.Title, err = ec.unmarshalNString2string(ctx, v)
10729			if err != nil {
10730				return it, err
10731			}
10732		}
10733	}
10734
10735	return it, nil
10736}
10737
10738// endregion **************************** input.gotpl *****************************
10739
10740// region    ************************** interface.gotpl ***************************
10741
10742func (ec *executionContext) _Authored(ctx context.Context, sel ast.SelectionSet, obj *models.Authored) graphql.Marshaler {
10743	switch obj := (*obj).(type) {
10744	case nil:
10745		return graphql.Null
10746	case bug.Comment:
10747		return ec._Comment(ctx, sel, &obj)
10748	case *bug.Comment:
10749		return ec._Comment(ctx, sel, obj)
10750	case *bug.Snapshot:
10751		return ec._Bug(ctx, sel, obj)
10752	case *bug.CreateOperation:
10753		return ec._CreateOperation(ctx, sel, obj)
10754	case *bug.SetTitleOperation:
10755		return ec._SetTitleOperation(ctx, sel, obj)
10756	case *bug.AddCommentOperation:
10757		return ec._AddCommentOperation(ctx, sel, obj)
10758	case *bug.EditCommentOperation:
10759		return ec._EditCommentOperation(ctx, sel, obj)
10760	case *bug.SetStatusOperation:
10761		return ec._SetStatusOperation(ctx, sel, obj)
10762	case *bug.LabelChangeOperation:
10763		return ec._LabelChangeOperation(ctx, sel, obj)
10764	case *bug.CreateTimelineItem:
10765		return ec._CreateTimelineItem(ctx, sel, obj)
10766	case *bug.AddCommentTimelineItem:
10767		return ec._AddCommentTimelineItem(ctx, sel, obj)
10768	case *bug.LabelChangeTimelineItem:
10769		return ec._LabelChangeTimelineItem(ctx, sel, obj)
10770	case *bug.SetStatusTimelineItem:
10771		return ec._SetStatusTimelineItem(ctx, sel, obj)
10772	case *bug.SetTitleTimelineItem:
10773		return ec._SetTitleTimelineItem(ctx, sel, obj)
10774	default:
10775		panic(fmt.Errorf("unexpected type %T", obj))
10776	}
10777}
10778
10779func (ec *executionContext) _Operation(ctx context.Context, sel ast.SelectionSet, obj *bug.Operation) graphql.Marshaler {
10780	switch obj := (*obj).(type) {
10781	case nil:
10782		return graphql.Null
10783	case *bug.CreateOperation:
10784		return ec._CreateOperation(ctx, sel, obj)
10785	case *bug.SetTitleOperation:
10786		return ec._SetTitleOperation(ctx, sel, obj)
10787	case *bug.AddCommentOperation:
10788		return ec._AddCommentOperation(ctx, sel, obj)
10789	case *bug.EditCommentOperation:
10790		return ec._EditCommentOperation(ctx, sel, obj)
10791	case *bug.SetStatusOperation:
10792		return ec._SetStatusOperation(ctx, sel, obj)
10793	case *bug.LabelChangeOperation:
10794		return ec._LabelChangeOperation(ctx, sel, obj)
10795	default:
10796		panic(fmt.Errorf("unexpected type %T", obj))
10797	}
10798}
10799
10800func (ec *executionContext) _TimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.TimelineItem) graphql.Marshaler {
10801	switch obj := (*obj).(type) {
10802	case nil:
10803		return graphql.Null
10804	case *bug.CreateTimelineItem:
10805		return ec._CreateTimelineItem(ctx, sel, obj)
10806	case *bug.AddCommentTimelineItem:
10807		return ec._AddCommentTimelineItem(ctx, sel, obj)
10808	case bug.LabelChangeTimelineItem:
10809		return ec._LabelChangeTimelineItem(ctx, sel, &obj)
10810	case *bug.LabelChangeTimelineItem:
10811		return ec._LabelChangeTimelineItem(ctx, sel, obj)
10812	case bug.SetStatusTimelineItem:
10813		return ec._SetStatusTimelineItem(ctx, sel, &obj)
10814	case *bug.SetStatusTimelineItem:
10815		return ec._SetStatusTimelineItem(ctx, sel, obj)
10816	case bug.SetTitleTimelineItem:
10817		return ec._SetTitleTimelineItem(ctx, sel, &obj)
10818	case *bug.SetTitleTimelineItem:
10819		return ec._SetTitleTimelineItem(ctx, sel, obj)
10820	default:
10821		panic(fmt.Errorf("unexpected type %T", obj))
10822	}
10823}
10824
10825// endregion ************************** interface.gotpl ***************************
10826
10827// region    **************************** object.gotpl ****************************
10828
10829var addCommentOperationImplementors = []string{"AddCommentOperation", "Operation", "Authored"}
10830
10831func (ec *executionContext) _AddCommentOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.AddCommentOperation) graphql.Marshaler {
10832	fields := graphql.CollectFields(ec.RequestContext, sel, addCommentOperationImplementors)
10833
10834	out := graphql.NewFieldSet(fields)
10835	var invalids uint32
10836	for i, field := range fields {
10837		switch field.Name {
10838		case "__typename":
10839			out.Values[i] = graphql.MarshalString("AddCommentOperation")
10840		case "hash":
10841			out.Values[i] = ec._AddCommentOperation_hash(ctx, field, obj)
10842			if out.Values[i] == graphql.Null {
10843				atomic.AddUint32(&invalids, 1)
10844			}
10845		case "author":
10846			out.Values[i] = ec._AddCommentOperation_author(ctx, field, obj)
10847			if out.Values[i] == graphql.Null {
10848				atomic.AddUint32(&invalids, 1)
10849			}
10850		case "date":
10851			field := field
10852			out.Concurrently(i, func() (res graphql.Marshaler) {
10853				defer func() {
10854					if r := recover(); r != nil {
10855						ec.Error(ctx, ec.Recover(ctx, r))
10856					}
10857				}()
10858				res = ec._AddCommentOperation_date(ctx, field, obj)
10859				if res == graphql.Null {
10860					atomic.AddUint32(&invalids, 1)
10861				}
10862				return res
10863			})
10864		case "message":
10865			out.Values[i] = ec._AddCommentOperation_message(ctx, field, obj)
10866			if out.Values[i] == graphql.Null {
10867				atomic.AddUint32(&invalids, 1)
10868			}
10869		case "files":
10870			out.Values[i] = ec._AddCommentOperation_files(ctx, field, obj)
10871			if out.Values[i] == graphql.Null {
10872				atomic.AddUint32(&invalids, 1)
10873			}
10874		default:
10875			panic("unknown field " + strconv.Quote(field.Name))
10876		}
10877	}
10878	out.Dispatch()
10879	if invalids > 0 {
10880		return graphql.Null
10881	}
10882	return out
10883}
10884
10885var addCommentPayloadImplementors = []string{"AddCommentPayload"}
10886
10887func (ec *executionContext) _AddCommentPayload(ctx context.Context, sel ast.SelectionSet, obj *models.AddCommentPayload) graphql.Marshaler {
10888	fields := graphql.CollectFields(ec.RequestContext, sel, addCommentPayloadImplementors)
10889
10890	out := graphql.NewFieldSet(fields)
10891	var invalids uint32
10892	for i, field := range fields {
10893		switch field.Name {
10894		case "__typename":
10895			out.Values[i] = graphql.MarshalString("AddCommentPayload")
10896		case "clientMutationId":
10897			out.Values[i] = ec._AddCommentPayload_clientMutationId(ctx, field, obj)
10898		case "bug":
10899			out.Values[i] = ec._AddCommentPayload_bug(ctx, field, obj)
10900			if out.Values[i] == graphql.Null {
10901				invalids++
10902			}
10903		case "operation":
10904			out.Values[i] = ec._AddCommentPayload_operation(ctx, field, obj)
10905			if out.Values[i] == graphql.Null {
10906				invalids++
10907			}
10908		default:
10909			panic("unknown field " + strconv.Quote(field.Name))
10910		}
10911	}
10912	out.Dispatch()
10913	if invalids > 0 {
10914		return graphql.Null
10915	}
10916	return out
10917}
10918
10919var addCommentTimelineItemImplementors = []string{"AddCommentTimelineItem", "TimelineItem", "Authored"}
10920
10921func (ec *executionContext) _AddCommentTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
10922	fields := graphql.CollectFields(ec.RequestContext, sel, addCommentTimelineItemImplementors)
10923
10924	out := graphql.NewFieldSet(fields)
10925	var invalids uint32
10926	for i, field := range fields {
10927		switch field.Name {
10928		case "__typename":
10929			out.Values[i] = graphql.MarshalString("AddCommentTimelineItem")
10930		case "hash":
10931			out.Values[i] = ec._AddCommentTimelineItem_hash(ctx, field, obj)
10932			if out.Values[i] == graphql.Null {
10933				atomic.AddUint32(&invalids, 1)
10934			}
10935		case "author":
10936			out.Values[i] = ec._AddCommentTimelineItem_author(ctx, field, obj)
10937			if out.Values[i] == graphql.Null {
10938				atomic.AddUint32(&invalids, 1)
10939			}
10940		case "message":
10941			out.Values[i] = ec._AddCommentTimelineItem_message(ctx, field, obj)
10942			if out.Values[i] == graphql.Null {
10943				atomic.AddUint32(&invalids, 1)
10944			}
10945		case "messageIsEmpty":
10946			out.Values[i] = ec._AddCommentTimelineItem_messageIsEmpty(ctx, field, obj)
10947			if out.Values[i] == graphql.Null {
10948				atomic.AddUint32(&invalids, 1)
10949			}
10950		case "files":
10951			out.Values[i] = ec._AddCommentTimelineItem_files(ctx, field, obj)
10952			if out.Values[i] == graphql.Null {
10953				atomic.AddUint32(&invalids, 1)
10954			}
10955		case "createdAt":
10956			field := field
10957			out.Concurrently(i, func() (res graphql.Marshaler) {
10958				defer func() {
10959					if r := recover(); r != nil {
10960						ec.Error(ctx, ec.Recover(ctx, r))
10961					}
10962				}()
10963				res = ec._AddCommentTimelineItem_createdAt(ctx, field, obj)
10964				if res == graphql.Null {
10965					atomic.AddUint32(&invalids, 1)
10966				}
10967				return res
10968			})
10969		case "lastEdit":
10970			field := field
10971			out.Concurrently(i, func() (res graphql.Marshaler) {
10972				defer func() {
10973					if r := recover(); r != nil {
10974						ec.Error(ctx, ec.Recover(ctx, r))
10975					}
10976				}()
10977				res = ec._AddCommentTimelineItem_lastEdit(ctx, field, obj)
10978				if res == graphql.Null {
10979					atomic.AddUint32(&invalids, 1)
10980				}
10981				return res
10982			})
10983		case "edited":
10984			out.Values[i] = ec._AddCommentTimelineItem_edited(ctx, field, obj)
10985			if out.Values[i] == graphql.Null {
10986				atomic.AddUint32(&invalids, 1)
10987			}
10988		case "history":
10989			out.Values[i] = ec._AddCommentTimelineItem_history(ctx, field, obj)
10990			if out.Values[i] == graphql.Null {
10991				atomic.AddUint32(&invalids, 1)
10992			}
10993		default:
10994			panic("unknown field " + strconv.Quote(field.Name))
10995		}
10996	}
10997	out.Dispatch()
10998	if invalids > 0 {
10999		return graphql.Null
11000	}
11001	return out
11002}
11003
11004var bugImplementors = []string{"Bug", "Authored"}
11005
11006func (ec *executionContext) _Bug(ctx context.Context, sel ast.SelectionSet, obj *bug.Snapshot) graphql.Marshaler {
11007	fields := graphql.CollectFields(ec.RequestContext, sel, bugImplementors)
11008
11009	out := graphql.NewFieldSet(fields)
11010	var invalids uint32
11011	for i, field := range fields {
11012		switch field.Name {
11013		case "__typename":
11014			out.Values[i] = graphql.MarshalString("Bug")
11015		case "id":
11016			out.Values[i] = ec._Bug_id(ctx, field, obj)
11017			if out.Values[i] == graphql.Null {
11018				atomic.AddUint32(&invalids, 1)
11019			}
11020		case "humanId":
11021			out.Values[i] = ec._Bug_humanId(ctx, field, obj)
11022			if out.Values[i] == graphql.Null {
11023				atomic.AddUint32(&invalids, 1)
11024			}
11025		case "status":
11026			field := field
11027			out.Concurrently(i, func() (res graphql.Marshaler) {
11028				defer func() {
11029					if r := recover(); r != nil {
11030						ec.Error(ctx, ec.Recover(ctx, r))
11031					}
11032				}()
11033				res = ec._Bug_status(ctx, field, obj)
11034				if res == graphql.Null {
11035					atomic.AddUint32(&invalids, 1)
11036				}
11037				return res
11038			})
11039		case "title":
11040			out.Values[i] = ec._Bug_title(ctx, field, obj)
11041			if out.Values[i] == graphql.Null {
11042				atomic.AddUint32(&invalids, 1)
11043			}
11044		case "labels":
11045			out.Values[i] = ec._Bug_labels(ctx, field, obj)
11046			if out.Values[i] == graphql.Null {
11047				atomic.AddUint32(&invalids, 1)
11048			}
11049		case "author":
11050			out.Values[i] = ec._Bug_author(ctx, field, obj)
11051			if out.Values[i] == graphql.Null {
11052				atomic.AddUint32(&invalids, 1)
11053			}
11054		case "createdAt":
11055			out.Values[i] = ec._Bug_createdAt(ctx, field, obj)
11056			if out.Values[i] == graphql.Null {
11057				atomic.AddUint32(&invalids, 1)
11058			}
11059		case "lastEdit":
11060			field := field
11061			out.Concurrently(i, func() (res graphql.Marshaler) {
11062				defer func() {
11063					if r := recover(); r != nil {
11064						ec.Error(ctx, ec.Recover(ctx, r))
11065					}
11066				}()
11067				res = ec._Bug_lastEdit(ctx, field, obj)
11068				if res == graphql.Null {
11069					atomic.AddUint32(&invalids, 1)
11070				}
11071				return res
11072			})
11073		case "actors":
11074			field := field
11075			out.Concurrently(i, func() (res graphql.Marshaler) {
11076				defer func() {
11077					if r := recover(); r != nil {
11078						ec.Error(ctx, ec.Recover(ctx, r))
11079					}
11080				}()
11081				res = ec._Bug_actors(ctx, field, obj)
11082				if res == graphql.Null {
11083					atomic.AddUint32(&invalids, 1)
11084				}
11085				return res
11086			})
11087		case "participants":
11088			field := field
11089			out.Concurrently(i, func() (res graphql.Marshaler) {
11090				defer func() {
11091					if r := recover(); r != nil {
11092						ec.Error(ctx, ec.Recover(ctx, r))
11093					}
11094				}()
11095				res = ec._Bug_participants(ctx, field, obj)
11096				if res == graphql.Null {
11097					atomic.AddUint32(&invalids, 1)
11098				}
11099				return res
11100			})
11101		case "comments":
11102			field := field
11103			out.Concurrently(i, func() (res graphql.Marshaler) {
11104				defer func() {
11105					if r := recover(); r != nil {
11106						ec.Error(ctx, ec.Recover(ctx, r))
11107					}
11108				}()
11109				res = ec._Bug_comments(ctx, field, obj)
11110				if res == graphql.Null {
11111					atomic.AddUint32(&invalids, 1)
11112				}
11113				return res
11114			})
11115		case "timeline":
11116			field := field
11117			out.Concurrently(i, func() (res graphql.Marshaler) {
11118				defer func() {
11119					if r := recover(); r != nil {
11120						ec.Error(ctx, ec.Recover(ctx, r))
11121					}
11122				}()
11123				res = ec._Bug_timeline(ctx, field, obj)
11124				if res == graphql.Null {
11125					atomic.AddUint32(&invalids, 1)
11126				}
11127				return res
11128			})
11129		case "operations":
11130			field := field
11131			out.Concurrently(i, func() (res graphql.Marshaler) {
11132				defer func() {
11133					if r := recover(); r != nil {
11134						ec.Error(ctx, ec.Recover(ctx, r))
11135					}
11136				}()
11137				res = ec._Bug_operations(ctx, field, obj)
11138				if res == graphql.Null {
11139					atomic.AddUint32(&invalids, 1)
11140				}
11141				return res
11142			})
11143		default:
11144			panic("unknown field " + strconv.Quote(field.Name))
11145		}
11146	}
11147	out.Dispatch()
11148	if invalids > 0 {
11149		return graphql.Null
11150	}
11151	return out
11152}
11153
11154var bugConnectionImplementors = []string{"BugConnection"}
11155
11156func (ec *executionContext) _BugConnection(ctx context.Context, sel ast.SelectionSet, obj *models.BugConnection) graphql.Marshaler {
11157	fields := graphql.CollectFields(ec.RequestContext, sel, bugConnectionImplementors)
11158
11159	out := graphql.NewFieldSet(fields)
11160	var invalids uint32
11161	for i, field := range fields {
11162		switch field.Name {
11163		case "__typename":
11164			out.Values[i] = graphql.MarshalString("BugConnection")
11165		case "edges":
11166			out.Values[i] = ec._BugConnection_edges(ctx, field, obj)
11167			if out.Values[i] == graphql.Null {
11168				invalids++
11169			}
11170		case "nodes":
11171			out.Values[i] = ec._BugConnection_nodes(ctx, field, obj)
11172			if out.Values[i] == graphql.Null {
11173				invalids++
11174			}
11175		case "pageInfo":
11176			out.Values[i] = ec._BugConnection_pageInfo(ctx, field, obj)
11177			if out.Values[i] == graphql.Null {
11178				invalids++
11179			}
11180		case "totalCount":
11181			out.Values[i] = ec._BugConnection_totalCount(ctx, field, obj)
11182			if out.Values[i] == graphql.Null {
11183				invalids++
11184			}
11185		default:
11186			panic("unknown field " + strconv.Quote(field.Name))
11187		}
11188	}
11189	out.Dispatch()
11190	if invalids > 0 {
11191		return graphql.Null
11192	}
11193	return out
11194}
11195
11196var bugEdgeImplementors = []string{"BugEdge"}
11197
11198func (ec *executionContext) _BugEdge(ctx context.Context, sel ast.SelectionSet, obj *models.BugEdge) graphql.Marshaler {
11199	fields := graphql.CollectFields(ec.RequestContext, sel, bugEdgeImplementors)
11200
11201	out := graphql.NewFieldSet(fields)
11202	var invalids uint32
11203	for i, field := range fields {
11204		switch field.Name {
11205		case "__typename":
11206			out.Values[i] = graphql.MarshalString("BugEdge")
11207		case "cursor":
11208			out.Values[i] = ec._BugEdge_cursor(ctx, field, obj)
11209			if out.Values[i] == graphql.Null {
11210				invalids++
11211			}
11212		case "node":
11213			out.Values[i] = ec._BugEdge_node(ctx, field, obj)
11214			if out.Values[i] == graphql.Null {
11215				invalids++
11216			}
11217		default:
11218			panic("unknown field " + strconv.Quote(field.Name))
11219		}
11220	}
11221	out.Dispatch()
11222	if invalids > 0 {
11223		return graphql.Null
11224	}
11225	return out
11226}
11227
11228var changeLabelPayloadImplementors = []string{"ChangeLabelPayload"}
11229
11230func (ec *executionContext) _ChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, obj *models.ChangeLabelPayload) graphql.Marshaler {
11231	fields := graphql.CollectFields(ec.RequestContext, sel, changeLabelPayloadImplementors)
11232
11233	out := graphql.NewFieldSet(fields)
11234	var invalids uint32
11235	for i, field := range fields {
11236		switch field.Name {
11237		case "__typename":
11238			out.Values[i] = graphql.MarshalString("ChangeLabelPayload")
11239		case "clientMutationId":
11240			out.Values[i] = ec._ChangeLabelPayload_clientMutationId(ctx, field, obj)
11241		case "bug":
11242			out.Values[i] = ec._ChangeLabelPayload_bug(ctx, field, obj)
11243			if out.Values[i] == graphql.Null {
11244				invalids++
11245			}
11246		case "operation":
11247			out.Values[i] = ec._ChangeLabelPayload_operation(ctx, field, obj)
11248			if out.Values[i] == graphql.Null {
11249				invalids++
11250			}
11251		case "results":
11252			out.Values[i] = ec._ChangeLabelPayload_results(ctx, field, obj)
11253			if out.Values[i] == graphql.Null {
11254				invalids++
11255			}
11256		default:
11257			panic("unknown field " + strconv.Quote(field.Name))
11258		}
11259	}
11260	out.Dispatch()
11261	if invalids > 0 {
11262		return graphql.Null
11263	}
11264	return out
11265}
11266
11267var closeBugPayloadImplementors = []string{"CloseBugPayload"}
11268
11269func (ec *executionContext) _CloseBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.CloseBugPayload) graphql.Marshaler {
11270	fields := graphql.CollectFields(ec.RequestContext, sel, closeBugPayloadImplementors)
11271
11272	out := graphql.NewFieldSet(fields)
11273	var invalids uint32
11274	for i, field := range fields {
11275		switch field.Name {
11276		case "__typename":
11277			out.Values[i] = graphql.MarshalString("CloseBugPayload")
11278		case "clientMutationId":
11279			out.Values[i] = ec._CloseBugPayload_clientMutationId(ctx, field, obj)
11280		case "bug":
11281			out.Values[i] = ec._CloseBugPayload_bug(ctx, field, obj)
11282			if out.Values[i] == graphql.Null {
11283				invalids++
11284			}
11285		case "operation":
11286			out.Values[i] = ec._CloseBugPayload_operation(ctx, field, obj)
11287			if out.Values[i] == graphql.Null {
11288				invalids++
11289			}
11290		default:
11291			panic("unknown field " + strconv.Quote(field.Name))
11292		}
11293	}
11294	out.Dispatch()
11295	if invalids > 0 {
11296		return graphql.Null
11297	}
11298	return out
11299}
11300
11301var colorImplementors = []string{"Color"}
11302
11303func (ec *executionContext) _Color(ctx context.Context, sel ast.SelectionSet, obj *color.RGBA) graphql.Marshaler {
11304	fields := graphql.CollectFields(ec.RequestContext, sel, colorImplementors)
11305
11306	out := graphql.NewFieldSet(fields)
11307	var invalids uint32
11308	for i, field := range fields {
11309		switch field.Name {
11310		case "__typename":
11311			out.Values[i] = graphql.MarshalString("Color")
11312		case "R":
11313			field := field
11314			out.Concurrently(i, func() (res graphql.Marshaler) {
11315				defer func() {
11316					if r := recover(); r != nil {
11317						ec.Error(ctx, ec.Recover(ctx, r))
11318					}
11319				}()
11320				res = ec._Color_R(ctx, field, obj)
11321				if res == graphql.Null {
11322					atomic.AddUint32(&invalids, 1)
11323				}
11324				return res
11325			})
11326		case "G":
11327			field := field
11328			out.Concurrently(i, func() (res graphql.Marshaler) {
11329				defer func() {
11330					if r := recover(); r != nil {
11331						ec.Error(ctx, ec.Recover(ctx, r))
11332					}
11333				}()
11334				res = ec._Color_G(ctx, field, obj)
11335				if res == graphql.Null {
11336					atomic.AddUint32(&invalids, 1)
11337				}
11338				return res
11339			})
11340		case "B":
11341			field := field
11342			out.Concurrently(i, func() (res graphql.Marshaler) {
11343				defer func() {
11344					if r := recover(); r != nil {
11345						ec.Error(ctx, ec.Recover(ctx, r))
11346					}
11347				}()
11348				res = ec._Color_B(ctx, field, obj)
11349				if res == graphql.Null {
11350					atomic.AddUint32(&invalids, 1)
11351				}
11352				return res
11353			})
11354		default:
11355			panic("unknown field " + strconv.Quote(field.Name))
11356		}
11357	}
11358	out.Dispatch()
11359	if invalids > 0 {
11360		return graphql.Null
11361	}
11362	return out
11363}
11364
11365var commentImplementors = []string{"Comment", "Authored"}
11366
11367func (ec *executionContext) _Comment(ctx context.Context, sel ast.SelectionSet, obj *bug.Comment) graphql.Marshaler {
11368	fields := graphql.CollectFields(ec.RequestContext, sel, commentImplementors)
11369
11370	out := graphql.NewFieldSet(fields)
11371	var invalids uint32
11372	for i, field := range fields {
11373		switch field.Name {
11374		case "__typename":
11375			out.Values[i] = graphql.MarshalString("Comment")
11376		case "author":
11377			out.Values[i] = ec._Comment_author(ctx, field, obj)
11378			if out.Values[i] == graphql.Null {
11379				invalids++
11380			}
11381		case "message":
11382			out.Values[i] = ec._Comment_message(ctx, field, obj)
11383			if out.Values[i] == graphql.Null {
11384				invalids++
11385			}
11386		case "files":
11387			out.Values[i] = ec._Comment_files(ctx, field, obj)
11388			if out.Values[i] == graphql.Null {
11389				invalids++
11390			}
11391		default:
11392			panic("unknown field " + strconv.Quote(field.Name))
11393		}
11394	}
11395	out.Dispatch()
11396	if invalids > 0 {
11397		return graphql.Null
11398	}
11399	return out
11400}
11401
11402var commentConnectionImplementors = []string{"CommentConnection"}
11403
11404func (ec *executionContext) _CommentConnection(ctx context.Context, sel ast.SelectionSet, obj *models.CommentConnection) graphql.Marshaler {
11405	fields := graphql.CollectFields(ec.RequestContext, sel, commentConnectionImplementors)
11406
11407	out := graphql.NewFieldSet(fields)
11408	var invalids uint32
11409	for i, field := range fields {
11410		switch field.Name {
11411		case "__typename":
11412			out.Values[i] = graphql.MarshalString("CommentConnection")
11413		case "edges":
11414			out.Values[i] = ec._CommentConnection_edges(ctx, field, obj)
11415			if out.Values[i] == graphql.Null {
11416				invalids++
11417			}
11418		case "nodes":
11419			out.Values[i] = ec._CommentConnection_nodes(ctx, field, obj)
11420			if out.Values[i] == graphql.Null {
11421				invalids++
11422			}
11423		case "pageInfo":
11424			out.Values[i] = ec._CommentConnection_pageInfo(ctx, field, obj)
11425			if out.Values[i] == graphql.Null {
11426				invalids++
11427			}
11428		case "totalCount":
11429			out.Values[i] = ec._CommentConnection_totalCount(ctx, field, obj)
11430			if out.Values[i] == graphql.Null {
11431				invalids++
11432			}
11433		default:
11434			panic("unknown field " + strconv.Quote(field.Name))
11435		}
11436	}
11437	out.Dispatch()
11438	if invalids > 0 {
11439		return graphql.Null
11440	}
11441	return out
11442}
11443
11444var commentEdgeImplementors = []string{"CommentEdge"}
11445
11446func (ec *executionContext) _CommentEdge(ctx context.Context, sel ast.SelectionSet, obj *models.CommentEdge) graphql.Marshaler {
11447	fields := graphql.CollectFields(ec.RequestContext, sel, commentEdgeImplementors)
11448
11449	out := graphql.NewFieldSet(fields)
11450	var invalids uint32
11451	for i, field := range fields {
11452		switch field.Name {
11453		case "__typename":
11454			out.Values[i] = graphql.MarshalString("CommentEdge")
11455		case "cursor":
11456			out.Values[i] = ec._CommentEdge_cursor(ctx, field, obj)
11457			if out.Values[i] == graphql.Null {
11458				invalids++
11459			}
11460		case "node":
11461			out.Values[i] = ec._CommentEdge_node(ctx, field, obj)
11462			if out.Values[i] == graphql.Null {
11463				invalids++
11464			}
11465		default:
11466			panic("unknown field " + strconv.Quote(field.Name))
11467		}
11468	}
11469	out.Dispatch()
11470	if invalids > 0 {
11471		return graphql.Null
11472	}
11473	return out
11474}
11475
11476var commentHistoryStepImplementors = []string{"CommentHistoryStep"}
11477
11478func (ec *executionContext) _CommentHistoryStep(ctx context.Context, sel ast.SelectionSet, obj *bug.CommentHistoryStep) graphql.Marshaler {
11479	fields := graphql.CollectFields(ec.RequestContext, sel, commentHistoryStepImplementors)
11480
11481	out := graphql.NewFieldSet(fields)
11482	var invalids uint32
11483	for i, field := range fields {
11484		switch field.Name {
11485		case "__typename":
11486			out.Values[i] = graphql.MarshalString("CommentHistoryStep")
11487		case "message":
11488			out.Values[i] = ec._CommentHistoryStep_message(ctx, field, obj)
11489			if out.Values[i] == graphql.Null {
11490				atomic.AddUint32(&invalids, 1)
11491			}
11492		case "date":
11493			field := field
11494			out.Concurrently(i, func() (res graphql.Marshaler) {
11495				defer func() {
11496					if r := recover(); r != nil {
11497						ec.Error(ctx, ec.Recover(ctx, r))
11498					}
11499				}()
11500				res = ec._CommentHistoryStep_date(ctx, field, obj)
11501				if res == graphql.Null {
11502					atomic.AddUint32(&invalids, 1)
11503				}
11504				return res
11505			})
11506		default:
11507			panic("unknown field " + strconv.Quote(field.Name))
11508		}
11509	}
11510	out.Dispatch()
11511	if invalids > 0 {
11512		return graphql.Null
11513	}
11514	return out
11515}
11516
11517var commitAsNeededPayloadImplementors = []string{"CommitAsNeededPayload"}
11518
11519func (ec *executionContext) _CommitAsNeededPayload(ctx context.Context, sel ast.SelectionSet, obj *models.CommitAsNeededPayload) graphql.Marshaler {
11520	fields := graphql.CollectFields(ec.RequestContext, sel, commitAsNeededPayloadImplementors)
11521
11522	out := graphql.NewFieldSet(fields)
11523	var invalids uint32
11524	for i, field := range fields {
11525		switch field.Name {
11526		case "__typename":
11527			out.Values[i] = graphql.MarshalString("CommitAsNeededPayload")
11528		case "clientMutationId":
11529			out.Values[i] = ec._CommitAsNeededPayload_clientMutationId(ctx, field, obj)
11530		case "bug":
11531			out.Values[i] = ec._CommitAsNeededPayload_bug(ctx, field, obj)
11532			if out.Values[i] == graphql.Null {
11533				invalids++
11534			}
11535		default:
11536			panic("unknown field " + strconv.Quote(field.Name))
11537		}
11538	}
11539	out.Dispatch()
11540	if invalids > 0 {
11541		return graphql.Null
11542	}
11543	return out
11544}
11545
11546var commitPayloadImplementors = []string{"CommitPayload"}
11547
11548func (ec *executionContext) _CommitPayload(ctx context.Context, sel ast.SelectionSet, obj *models.CommitPayload) graphql.Marshaler {
11549	fields := graphql.CollectFields(ec.RequestContext, sel, commitPayloadImplementors)
11550
11551	out := graphql.NewFieldSet(fields)
11552	var invalids uint32
11553	for i, field := range fields {
11554		switch field.Name {
11555		case "__typename":
11556			out.Values[i] = graphql.MarshalString("CommitPayload")
11557		case "clientMutationId":
11558			out.Values[i] = ec._CommitPayload_clientMutationId(ctx, field, obj)
11559		case "bug":
11560			out.Values[i] = ec._CommitPayload_bug(ctx, field, obj)
11561			if out.Values[i] == graphql.Null {
11562				invalids++
11563			}
11564		default:
11565			panic("unknown field " + strconv.Quote(field.Name))
11566		}
11567	}
11568	out.Dispatch()
11569	if invalids > 0 {
11570		return graphql.Null
11571	}
11572	return out
11573}
11574
11575var createOperationImplementors = []string{"CreateOperation", "Operation", "Authored"}
11576
11577func (ec *executionContext) _CreateOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.CreateOperation) graphql.Marshaler {
11578	fields := graphql.CollectFields(ec.RequestContext, sel, createOperationImplementors)
11579
11580	out := graphql.NewFieldSet(fields)
11581	var invalids uint32
11582	for i, field := range fields {
11583		switch field.Name {
11584		case "__typename":
11585			out.Values[i] = graphql.MarshalString("CreateOperation")
11586		case "hash":
11587			out.Values[i] = ec._CreateOperation_hash(ctx, field, obj)
11588			if out.Values[i] == graphql.Null {
11589				atomic.AddUint32(&invalids, 1)
11590			}
11591		case "author":
11592			out.Values[i] = ec._CreateOperation_author(ctx, field, obj)
11593			if out.Values[i] == graphql.Null {
11594				atomic.AddUint32(&invalids, 1)
11595			}
11596		case "date":
11597			field := field
11598			out.Concurrently(i, func() (res graphql.Marshaler) {
11599				defer func() {
11600					if r := recover(); r != nil {
11601						ec.Error(ctx, ec.Recover(ctx, r))
11602					}
11603				}()
11604				res = ec._CreateOperation_date(ctx, field, obj)
11605				if res == graphql.Null {
11606					atomic.AddUint32(&invalids, 1)
11607				}
11608				return res
11609			})
11610		case "title":
11611			out.Values[i] = ec._CreateOperation_title(ctx, field, obj)
11612			if out.Values[i] == graphql.Null {
11613				atomic.AddUint32(&invalids, 1)
11614			}
11615		case "message":
11616			out.Values[i] = ec._CreateOperation_message(ctx, field, obj)
11617			if out.Values[i] == graphql.Null {
11618				atomic.AddUint32(&invalids, 1)
11619			}
11620		case "files":
11621			out.Values[i] = ec._CreateOperation_files(ctx, field, obj)
11622			if out.Values[i] == graphql.Null {
11623				atomic.AddUint32(&invalids, 1)
11624			}
11625		default:
11626			panic("unknown field " + strconv.Quote(field.Name))
11627		}
11628	}
11629	out.Dispatch()
11630	if invalids > 0 {
11631		return graphql.Null
11632	}
11633	return out
11634}
11635
11636var createTimelineItemImplementors = []string{"CreateTimelineItem", "TimelineItem", "Authored"}
11637
11638func (ec *executionContext) _CreateTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.CreateTimelineItem) graphql.Marshaler {
11639	fields := graphql.CollectFields(ec.RequestContext, sel, createTimelineItemImplementors)
11640
11641	out := graphql.NewFieldSet(fields)
11642	var invalids uint32
11643	for i, field := range fields {
11644		switch field.Name {
11645		case "__typename":
11646			out.Values[i] = graphql.MarshalString("CreateTimelineItem")
11647		case "hash":
11648			out.Values[i] = ec._CreateTimelineItem_hash(ctx, field, obj)
11649			if out.Values[i] == graphql.Null {
11650				atomic.AddUint32(&invalids, 1)
11651			}
11652		case "author":
11653			out.Values[i] = ec._CreateTimelineItem_author(ctx, field, obj)
11654			if out.Values[i] == graphql.Null {
11655				atomic.AddUint32(&invalids, 1)
11656			}
11657		case "message":
11658			out.Values[i] = ec._CreateTimelineItem_message(ctx, field, obj)
11659			if out.Values[i] == graphql.Null {
11660				atomic.AddUint32(&invalids, 1)
11661			}
11662		case "messageIsEmpty":
11663			out.Values[i] = ec._CreateTimelineItem_messageIsEmpty(ctx, field, obj)
11664			if out.Values[i] == graphql.Null {
11665				atomic.AddUint32(&invalids, 1)
11666			}
11667		case "files":
11668			out.Values[i] = ec._CreateTimelineItem_files(ctx, field, obj)
11669			if out.Values[i] == graphql.Null {
11670				atomic.AddUint32(&invalids, 1)
11671			}
11672		case "createdAt":
11673			field := field
11674			out.Concurrently(i, func() (res graphql.Marshaler) {
11675				defer func() {
11676					if r := recover(); r != nil {
11677						ec.Error(ctx, ec.Recover(ctx, r))
11678					}
11679				}()
11680				res = ec._CreateTimelineItem_createdAt(ctx, field, obj)
11681				if res == graphql.Null {
11682					atomic.AddUint32(&invalids, 1)
11683				}
11684				return res
11685			})
11686		case "lastEdit":
11687			field := field
11688			out.Concurrently(i, func() (res graphql.Marshaler) {
11689				defer func() {
11690					if r := recover(); r != nil {
11691						ec.Error(ctx, ec.Recover(ctx, r))
11692					}
11693				}()
11694				res = ec._CreateTimelineItem_lastEdit(ctx, field, obj)
11695				if res == graphql.Null {
11696					atomic.AddUint32(&invalids, 1)
11697				}
11698				return res
11699			})
11700		case "edited":
11701			out.Values[i] = ec._CreateTimelineItem_edited(ctx, field, obj)
11702			if out.Values[i] == graphql.Null {
11703				atomic.AddUint32(&invalids, 1)
11704			}
11705		case "history":
11706			out.Values[i] = ec._CreateTimelineItem_history(ctx, field, obj)
11707			if out.Values[i] == graphql.Null {
11708				atomic.AddUint32(&invalids, 1)
11709			}
11710		default:
11711			panic("unknown field " + strconv.Quote(field.Name))
11712		}
11713	}
11714	out.Dispatch()
11715	if invalids > 0 {
11716		return graphql.Null
11717	}
11718	return out
11719}
11720
11721var editCommentOperationImplementors = []string{"EditCommentOperation", "Operation", "Authored"}
11722
11723func (ec *executionContext) _EditCommentOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.EditCommentOperation) graphql.Marshaler {
11724	fields := graphql.CollectFields(ec.RequestContext, sel, editCommentOperationImplementors)
11725
11726	out := graphql.NewFieldSet(fields)
11727	var invalids uint32
11728	for i, field := range fields {
11729		switch field.Name {
11730		case "__typename":
11731			out.Values[i] = graphql.MarshalString("EditCommentOperation")
11732		case "hash":
11733			out.Values[i] = ec._EditCommentOperation_hash(ctx, field, obj)
11734			if out.Values[i] == graphql.Null {
11735				atomic.AddUint32(&invalids, 1)
11736			}
11737		case "author":
11738			out.Values[i] = ec._EditCommentOperation_author(ctx, field, obj)
11739			if out.Values[i] == graphql.Null {
11740				atomic.AddUint32(&invalids, 1)
11741			}
11742		case "date":
11743			field := field
11744			out.Concurrently(i, func() (res graphql.Marshaler) {
11745				defer func() {
11746					if r := recover(); r != nil {
11747						ec.Error(ctx, ec.Recover(ctx, r))
11748					}
11749				}()
11750				res = ec._EditCommentOperation_date(ctx, field, obj)
11751				if res == graphql.Null {
11752					atomic.AddUint32(&invalids, 1)
11753				}
11754				return res
11755			})
11756		case "target":
11757			out.Values[i] = ec._EditCommentOperation_target(ctx, field, obj)
11758			if out.Values[i] == graphql.Null {
11759				atomic.AddUint32(&invalids, 1)
11760			}
11761		case "message":
11762			out.Values[i] = ec._EditCommentOperation_message(ctx, field, obj)
11763			if out.Values[i] == graphql.Null {
11764				atomic.AddUint32(&invalids, 1)
11765			}
11766		case "files":
11767			out.Values[i] = ec._EditCommentOperation_files(ctx, field, obj)
11768			if out.Values[i] == graphql.Null {
11769				atomic.AddUint32(&invalids, 1)
11770			}
11771		default:
11772			panic("unknown field " + strconv.Quote(field.Name))
11773		}
11774	}
11775	out.Dispatch()
11776	if invalids > 0 {
11777		return graphql.Null
11778	}
11779	return out
11780}
11781
11782var identityImplementors = []string{"Identity"}
11783
11784func (ec *executionContext) _Identity(ctx context.Context, sel ast.SelectionSet, obj *identity.Interface) graphql.Marshaler {
11785	fields := graphql.CollectFields(ec.RequestContext, sel, identityImplementors)
11786
11787	out := graphql.NewFieldSet(fields)
11788	var invalids uint32
11789	for i, field := range fields {
11790		switch field.Name {
11791		case "__typename":
11792			out.Values[i] = graphql.MarshalString("Identity")
11793		case "id":
11794			field := field
11795			out.Concurrently(i, func() (res graphql.Marshaler) {
11796				defer func() {
11797					if r := recover(); r != nil {
11798						ec.Error(ctx, ec.Recover(ctx, r))
11799					}
11800				}()
11801				res = ec._Identity_id(ctx, field, obj)
11802				if res == graphql.Null {
11803					atomic.AddUint32(&invalids, 1)
11804				}
11805				return res
11806			})
11807		case "humanId":
11808			field := field
11809			out.Concurrently(i, func() (res graphql.Marshaler) {
11810				defer func() {
11811					if r := recover(); r != nil {
11812						ec.Error(ctx, ec.Recover(ctx, r))
11813					}
11814				}()
11815				res = ec._Identity_humanId(ctx, field, obj)
11816				if res == graphql.Null {
11817					atomic.AddUint32(&invalids, 1)
11818				}
11819				return res
11820			})
11821		case "name":
11822			field := field
11823			out.Concurrently(i, func() (res graphql.Marshaler) {
11824				defer func() {
11825					if r := recover(); r != nil {
11826						ec.Error(ctx, ec.Recover(ctx, r))
11827					}
11828				}()
11829				res = ec._Identity_name(ctx, field, obj)
11830				return res
11831			})
11832		case "email":
11833			field := field
11834			out.Concurrently(i, func() (res graphql.Marshaler) {
11835				defer func() {
11836					if r := recover(); r != nil {
11837						ec.Error(ctx, ec.Recover(ctx, r))
11838					}
11839				}()
11840				res = ec._Identity_email(ctx, field, obj)
11841				return res
11842			})
11843		case "login":
11844			field := field
11845			out.Concurrently(i, func() (res graphql.Marshaler) {
11846				defer func() {
11847					if r := recover(); r != nil {
11848						ec.Error(ctx, ec.Recover(ctx, r))
11849					}
11850				}()
11851				res = ec._Identity_login(ctx, field, obj)
11852				return res
11853			})
11854		case "displayName":
11855			field := field
11856			out.Concurrently(i, func() (res graphql.Marshaler) {
11857				defer func() {
11858					if r := recover(); r != nil {
11859						ec.Error(ctx, ec.Recover(ctx, r))
11860					}
11861				}()
11862				res = ec._Identity_displayName(ctx, field, obj)
11863				if res == graphql.Null {
11864					atomic.AddUint32(&invalids, 1)
11865				}
11866				return res
11867			})
11868		case "avatarUrl":
11869			field := field
11870			out.Concurrently(i, func() (res graphql.Marshaler) {
11871				defer func() {
11872					if r := recover(); r != nil {
11873						ec.Error(ctx, ec.Recover(ctx, r))
11874					}
11875				}()
11876				res = ec._Identity_avatarUrl(ctx, field, obj)
11877				return res
11878			})
11879		case "isProtected":
11880			field := field
11881			out.Concurrently(i, func() (res graphql.Marshaler) {
11882				defer func() {
11883					if r := recover(); r != nil {
11884						ec.Error(ctx, ec.Recover(ctx, r))
11885					}
11886				}()
11887				res = ec._Identity_isProtected(ctx, field, obj)
11888				if res == graphql.Null {
11889					atomic.AddUint32(&invalids, 1)
11890				}
11891				return res
11892			})
11893		default:
11894			panic("unknown field " + strconv.Quote(field.Name))
11895		}
11896	}
11897	out.Dispatch()
11898	if invalids > 0 {
11899		return graphql.Null
11900	}
11901	return out
11902}
11903
11904var identityConnectionImplementors = []string{"IdentityConnection"}
11905
11906func (ec *executionContext) _IdentityConnection(ctx context.Context, sel ast.SelectionSet, obj *models.IdentityConnection) graphql.Marshaler {
11907	fields := graphql.CollectFields(ec.RequestContext, sel, identityConnectionImplementors)
11908
11909	out := graphql.NewFieldSet(fields)
11910	var invalids uint32
11911	for i, field := range fields {
11912		switch field.Name {
11913		case "__typename":
11914			out.Values[i] = graphql.MarshalString("IdentityConnection")
11915		case "edges":
11916			out.Values[i] = ec._IdentityConnection_edges(ctx, field, obj)
11917			if out.Values[i] == graphql.Null {
11918				invalids++
11919			}
11920		case "nodes":
11921			out.Values[i] = ec._IdentityConnection_nodes(ctx, field, obj)
11922			if out.Values[i] == graphql.Null {
11923				invalids++
11924			}
11925		case "pageInfo":
11926			out.Values[i] = ec._IdentityConnection_pageInfo(ctx, field, obj)
11927			if out.Values[i] == graphql.Null {
11928				invalids++
11929			}
11930		case "totalCount":
11931			out.Values[i] = ec._IdentityConnection_totalCount(ctx, field, obj)
11932			if out.Values[i] == graphql.Null {
11933				invalids++
11934			}
11935		default:
11936			panic("unknown field " + strconv.Quote(field.Name))
11937		}
11938	}
11939	out.Dispatch()
11940	if invalids > 0 {
11941		return graphql.Null
11942	}
11943	return out
11944}
11945
11946var identityEdgeImplementors = []string{"IdentityEdge"}
11947
11948func (ec *executionContext) _IdentityEdge(ctx context.Context, sel ast.SelectionSet, obj *models.IdentityEdge) graphql.Marshaler {
11949	fields := graphql.CollectFields(ec.RequestContext, sel, identityEdgeImplementors)
11950
11951	out := graphql.NewFieldSet(fields)
11952	var invalids uint32
11953	for i, field := range fields {
11954		switch field.Name {
11955		case "__typename":
11956			out.Values[i] = graphql.MarshalString("IdentityEdge")
11957		case "cursor":
11958			out.Values[i] = ec._IdentityEdge_cursor(ctx, field, obj)
11959			if out.Values[i] == graphql.Null {
11960				invalids++
11961			}
11962		case "node":
11963			out.Values[i] = ec._IdentityEdge_node(ctx, field, obj)
11964			if out.Values[i] == graphql.Null {
11965				invalids++
11966			}
11967		default:
11968			panic("unknown field " + strconv.Quote(field.Name))
11969		}
11970	}
11971	out.Dispatch()
11972	if invalids > 0 {
11973		return graphql.Null
11974	}
11975	return out
11976}
11977
11978var labelImplementors = []string{"Label"}
11979
11980func (ec *executionContext) _Label(ctx context.Context, sel ast.SelectionSet, obj *bug.Label) graphql.Marshaler {
11981	fields := graphql.CollectFields(ec.RequestContext, sel, labelImplementors)
11982
11983	out := graphql.NewFieldSet(fields)
11984	var invalids uint32
11985	for i, field := range fields {
11986		switch field.Name {
11987		case "__typename":
11988			out.Values[i] = graphql.MarshalString("Label")
11989		case "name":
11990			field := field
11991			out.Concurrently(i, func() (res graphql.Marshaler) {
11992				defer func() {
11993					if r := recover(); r != nil {
11994						ec.Error(ctx, ec.Recover(ctx, r))
11995					}
11996				}()
11997				res = ec._Label_name(ctx, field, obj)
11998				if res == graphql.Null {
11999					atomic.AddUint32(&invalids, 1)
12000				}
12001				return res
12002			})
12003		case "color":
12004			field := field
12005			out.Concurrently(i, func() (res graphql.Marshaler) {
12006				defer func() {
12007					if r := recover(); r != nil {
12008						ec.Error(ctx, ec.Recover(ctx, r))
12009					}
12010				}()
12011				res = ec._Label_color(ctx, field, obj)
12012				if res == graphql.Null {
12013					atomic.AddUint32(&invalids, 1)
12014				}
12015				return res
12016			})
12017		default:
12018			panic("unknown field " + strconv.Quote(field.Name))
12019		}
12020	}
12021	out.Dispatch()
12022	if invalids > 0 {
12023		return graphql.Null
12024	}
12025	return out
12026}
12027
12028var labelChangeOperationImplementors = []string{"LabelChangeOperation", "Operation", "Authored"}
12029
12030func (ec *executionContext) _LabelChangeOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeOperation) graphql.Marshaler {
12031	fields := graphql.CollectFields(ec.RequestContext, sel, labelChangeOperationImplementors)
12032
12033	out := graphql.NewFieldSet(fields)
12034	var invalids uint32
12035	for i, field := range fields {
12036		switch field.Name {
12037		case "__typename":
12038			out.Values[i] = graphql.MarshalString("LabelChangeOperation")
12039		case "hash":
12040			out.Values[i] = ec._LabelChangeOperation_hash(ctx, field, obj)
12041			if out.Values[i] == graphql.Null {
12042				atomic.AddUint32(&invalids, 1)
12043			}
12044		case "author":
12045			out.Values[i] = ec._LabelChangeOperation_author(ctx, field, obj)
12046			if out.Values[i] == graphql.Null {
12047				atomic.AddUint32(&invalids, 1)
12048			}
12049		case "date":
12050			field := field
12051			out.Concurrently(i, func() (res graphql.Marshaler) {
12052				defer func() {
12053					if r := recover(); r != nil {
12054						ec.Error(ctx, ec.Recover(ctx, r))
12055					}
12056				}()
12057				res = ec._LabelChangeOperation_date(ctx, field, obj)
12058				if res == graphql.Null {
12059					atomic.AddUint32(&invalids, 1)
12060				}
12061				return res
12062			})
12063		case "added":
12064			out.Values[i] = ec._LabelChangeOperation_added(ctx, field, obj)
12065			if out.Values[i] == graphql.Null {
12066				atomic.AddUint32(&invalids, 1)
12067			}
12068		case "removed":
12069			out.Values[i] = ec._LabelChangeOperation_removed(ctx, field, obj)
12070			if out.Values[i] == graphql.Null {
12071				atomic.AddUint32(&invalids, 1)
12072			}
12073		default:
12074			panic("unknown field " + strconv.Quote(field.Name))
12075		}
12076	}
12077	out.Dispatch()
12078	if invalids > 0 {
12079		return graphql.Null
12080	}
12081	return out
12082}
12083
12084var labelChangeResultImplementors = []string{"LabelChangeResult"}
12085
12086func (ec *executionContext) _LabelChangeResult(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeResult) graphql.Marshaler {
12087	fields := graphql.CollectFields(ec.RequestContext, sel, labelChangeResultImplementors)
12088
12089	out := graphql.NewFieldSet(fields)
12090	var invalids uint32
12091	for i, field := range fields {
12092		switch field.Name {
12093		case "__typename":
12094			out.Values[i] = graphql.MarshalString("LabelChangeResult")
12095		case "label":
12096			out.Values[i] = ec._LabelChangeResult_label(ctx, field, obj)
12097			if out.Values[i] == graphql.Null {
12098				atomic.AddUint32(&invalids, 1)
12099			}
12100		case "status":
12101			field := field
12102			out.Concurrently(i, func() (res graphql.Marshaler) {
12103				defer func() {
12104					if r := recover(); r != nil {
12105						ec.Error(ctx, ec.Recover(ctx, r))
12106					}
12107				}()
12108				res = ec._LabelChangeResult_status(ctx, field, obj)
12109				if res == graphql.Null {
12110					atomic.AddUint32(&invalids, 1)
12111				}
12112				return res
12113			})
12114		default:
12115			panic("unknown field " + strconv.Quote(field.Name))
12116		}
12117	}
12118	out.Dispatch()
12119	if invalids > 0 {
12120		return graphql.Null
12121	}
12122	return out
12123}
12124
12125var labelChangeTimelineItemImplementors = []string{"LabelChangeTimelineItem", "TimelineItem", "Authored"}
12126
12127func (ec *executionContext) _LabelChangeTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeTimelineItem) graphql.Marshaler {
12128	fields := graphql.CollectFields(ec.RequestContext, sel, labelChangeTimelineItemImplementors)
12129
12130	out := graphql.NewFieldSet(fields)
12131	var invalids uint32
12132	for i, field := range fields {
12133		switch field.Name {
12134		case "__typename":
12135			out.Values[i] = graphql.MarshalString("LabelChangeTimelineItem")
12136		case "hash":
12137			out.Values[i] = ec._LabelChangeTimelineItem_hash(ctx, field, obj)
12138			if out.Values[i] == graphql.Null {
12139				atomic.AddUint32(&invalids, 1)
12140			}
12141		case "author":
12142			out.Values[i] = ec._LabelChangeTimelineItem_author(ctx, field, obj)
12143			if out.Values[i] == graphql.Null {
12144				atomic.AddUint32(&invalids, 1)
12145			}
12146		case "date":
12147			field := field
12148			out.Concurrently(i, func() (res graphql.Marshaler) {
12149				defer func() {
12150					if r := recover(); r != nil {
12151						ec.Error(ctx, ec.Recover(ctx, r))
12152					}
12153				}()
12154				res = ec._LabelChangeTimelineItem_date(ctx, field, obj)
12155				if res == graphql.Null {
12156					atomic.AddUint32(&invalids, 1)
12157				}
12158				return res
12159			})
12160		case "added":
12161			out.Values[i] = ec._LabelChangeTimelineItem_added(ctx, field, obj)
12162			if out.Values[i] == graphql.Null {
12163				atomic.AddUint32(&invalids, 1)
12164			}
12165		case "removed":
12166			out.Values[i] = ec._LabelChangeTimelineItem_removed(ctx, field, obj)
12167			if out.Values[i] == graphql.Null {
12168				atomic.AddUint32(&invalids, 1)
12169			}
12170		default:
12171			panic("unknown field " + strconv.Quote(field.Name))
12172		}
12173	}
12174	out.Dispatch()
12175	if invalids > 0 {
12176		return graphql.Null
12177	}
12178	return out
12179}
12180
12181var mutationImplementors = []string{"Mutation"}
12182
12183func (ec *executionContext) _Mutation(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
12184	fields := graphql.CollectFields(ec.RequestContext, sel, mutationImplementors)
12185
12186	ctx = graphql.WithResolverContext(ctx, &graphql.ResolverContext{
12187		Object: "Mutation",
12188	})
12189
12190	out := graphql.NewFieldSet(fields)
12191	var invalids uint32
12192	for i, field := range fields {
12193		switch field.Name {
12194		case "__typename":
12195			out.Values[i] = graphql.MarshalString("Mutation")
12196		case "newBug":
12197			out.Values[i] = ec._Mutation_newBug(ctx, field)
12198			if out.Values[i] == graphql.Null {
12199				invalids++
12200			}
12201		case "addComment":
12202			out.Values[i] = ec._Mutation_addComment(ctx, field)
12203			if out.Values[i] == graphql.Null {
12204				invalids++
12205			}
12206		case "changeLabels":
12207			out.Values[i] = ec._Mutation_changeLabels(ctx, field)
12208			if out.Values[i] == graphql.Null {
12209				invalids++
12210			}
12211		case "openBug":
12212			out.Values[i] = ec._Mutation_openBug(ctx, field)
12213			if out.Values[i] == graphql.Null {
12214				invalids++
12215			}
12216		case "closeBug":
12217			out.Values[i] = ec._Mutation_closeBug(ctx, field)
12218			if out.Values[i] == graphql.Null {
12219				invalids++
12220			}
12221		case "setTitle":
12222			out.Values[i] = ec._Mutation_setTitle(ctx, field)
12223			if out.Values[i] == graphql.Null {
12224				invalids++
12225			}
12226		case "commit":
12227			out.Values[i] = ec._Mutation_commit(ctx, field)
12228			if out.Values[i] == graphql.Null {
12229				invalids++
12230			}
12231		case "commitAsNeeded":
12232			out.Values[i] = ec._Mutation_commitAsNeeded(ctx, field)
12233			if out.Values[i] == graphql.Null {
12234				invalids++
12235			}
12236		default:
12237			panic("unknown field " + strconv.Quote(field.Name))
12238		}
12239	}
12240	out.Dispatch()
12241	if invalids > 0 {
12242		return graphql.Null
12243	}
12244	return out
12245}
12246
12247var newBugPayloadImplementors = []string{"NewBugPayload"}
12248
12249func (ec *executionContext) _NewBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.NewBugPayload) graphql.Marshaler {
12250	fields := graphql.CollectFields(ec.RequestContext, sel, newBugPayloadImplementors)
12251
12252	out := graphql.NewFieldSet(fields)
12253	var invalids uint32
12254	for i, field := range fields {
12255		switch field.Name {
12256		case "__typename":
12257			out.Values[i] = graphql.MarshalString("NewBugPayload")
12258		case "clientMutationId":
12259			out.Values[i] = ec._NewBugPayload_clientMutationId(ctx, field, obj)
12260		case "bug":
12261			out.Values[i] = ec._NewBugPayload_bug(ctx, field, obj)
12262			if out.Values[i] == graphql.Null {
12263				invalids++
12264			}
12265		case "operation":
12266			out.Values[i] = ec._NewBugPayload_operation(ctx, field, obj)
12267			if out.Values[i] == graphql.Null {
12268				invalids++
12269			}
12270		default:
12271			panic("unknown field " + strconv.Quote(field.Name))
12272		}
12273	}
12274	out.Dispatch()
12275	if invalids > 0 {
12276		return graphql.Null
12277	}
12278	return out
12279}
12280
12281var openBugPayloadImplementors = []string{"OpenBugPayload"}
12282
12283func (ec *executionContext) _OpenBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.OpenBugPayload) graphql.Marshaler {
12284	fields := graphql.CollectFields(ec.RequestContext, sel, openBugPayloadImplementors)
12285
12286	out := graphql.NewFieldSet(fields)
12287	var invalids uint32
12288	for i, field := range fields {
12289		switch field.Name {
12290		case "__typename":
12291			out.Values[i] = graphql.MarshalString("OpenBugPayload")
12292		case "clientMutationId":
12293			out.Values[i] = ec._OpenBugPayload_clientMutationId(ctx, field, obj)
12294		case "bug":
12295			out.Values[i] = ec._OpenBugPayload_bug(ctx, field, obj)
12296			if out.Values[i] == graphql.Null {
12297				invalids++
12298			}
12299		case "operation":
12300			out.Values[i] = ec._OpenBugPayload_operation(ctx, field, obj)
12301			if out.Values[i] == graphql.Null {
12302				invalids++
12303			}
12304		default:
12305			panic("unknown field " + strconv.Quote(field.Name))
12306		}
12307	}
12308	out.Dispatch()
12309	if invalids > 0 {
12310		return graphql.Null
12311	}
12312	return out
12313}
12314
12315var operationConnectionImplementors = []string{"OperationConnection"}
12316
12317func (ec *executionContext) _OperationConnection(ctx context.Context, sel ast.SelectionSet, obj *models.OperationConnection) graphql.Marshaler {
12318	fields := graphql.CollectFields(ec.RequestContext, sel, operationConnectionImplementors)
12319
12320	out := graphql.NewFieldSet(fields)
12321	var invalids uint32
12322	for i, field := range fields {
12323		switch field.Name {
12324		case "__typename":
12325			out.Values[i] = graphql.MarshalString("OperationConnection")
12326		case "edges":
12327			out.Values[i] = ec._OperationConnection_edges(ctx, field, obj)
12328			if out.Values[i] == graphql.Null {
12329				invalids++
12330			}
12331		case "nodes":
12332			out.Values[i] = ec._OperationConnection_nodes(ctx, field, obj)
12333			if out.Values[i] == graphql.Null {
12334				invalids++
12335			}
12336		case "pageInfo":
12337			out.Values[i] = ec._OperationConnection_pageInfo(ctx, field, obj)
12338			if out.Values[i] == graphql.Null {
12339				invalids++
12340			}
12341		case "totalCount":
12342			out.Values[i] = ec._OperationConnection_totalCount(ctx, field, obj)
12343			if out.Values[i] == graphql.Null {
12344				invalids++
12345			}
12346		default:
12347			panic("unknown field " + strconv.Quote(field.Name))
12348		}
12349	}
12350	out.Dispatch()
12351	if invalids > 0 {
12352		return graphql.Null
12353	}
12354	return out
12355}
12356
12357var operationEdgeImplementors = []string{"OperationEdge"}
12358
12359func (ec *executionContext) _OperationEdge(ctx context.Context, sel ast.SelectionSet, obj *models.OperationEdge) graphql.Marshaler {
12360	fields := graphql.CollectFields(ec.RequestContext, sel, operationEdgeImplementors)
12361
12362	out := graphql.NewFieldSet(fields)
12363	var invalids uint32
12364	for i, field := range fields {
12365		switch field.Name {
12366		case "__typename":
12367			out.Values[i] = graphql.MarshalString("OperationEdge")
12368		case "cursor":
12369			out.Values[i] = ec._OperationEdge_cursor(ctx, field, obj)
12370			if out.Values[i] == graphql.Null {
12371				invalids++
12372			}
12373		case "node":
12374			out.Values[i] = ec._OperationEdge_node(ctx, field, obj)
12375			if out.Values[i] == graphql.Null {
12376				invalids++
12377			}
12378		default:
12379			panic("unknown field " + strconv.Quote(field.Name))
12380		}
12381	}
12382	out.Dispatch()
12383	if invalids > 0 {
12384		return graphql.Null
12385	}
12386	return out
12387}
12388
12389var pageInfoImplementors = []string{"PageInfo"}
12390
12391func (ec *executionContext) _PageInfo(ctx context.Context, sel ast.SelectionSet, obj *models.PageInfo) graphql.Marshaler {
12392	fields := graphql.CollectFields(ec.RequestContext, sel, pageInfoImplementors)
12393
12394	out := graphql.NewFieldSet(fields)
12395	var invalids uint32
12396	for i, field := range fields {
12397		switch field.Name {
12398		case "__typename":
12399			out.Values[i] = graphql.MarshalString("PageInfo")
12400		case "hasNextPage":
12401			out.Values[i] = ec._PageInfo_hasNextPage(ctx, field, obj)
12402			if out.Values[i] == graphql.Null {
12403				invalids++
12404			}
12405		case "hasPreviousPage":
12406			out.Values[i] = ec._PageInfo_hasPreviousPage(ctx, field, obj)
12407			if out.Values[i] == graphql.Null {
12408				invalids++
12409			}
12410		case "startCursor":
12411			out.Values[i] = ec._PageInfo_startCursor(ctx, field, obj)
12412			if out.Values[i] == graphql.Null {
12413				invalids++
12414			}
12415		case "endCursor":
12416			out.Values[i] = ec._PageInfo_endCursor(ctx, field, obj)
12417			if out.Values[i] == graphql.Null {
12418				invalids++
12419			}
12420		default:
12421			panic("unknown field " + strconv.Quote(field.Name))
12422		}
12423	}
12424	out.Dispatch()
12425	if invalids > 0 {
12426		return graphql.Null
12427	}
12428	return out
12429}
12430
12431var queryImplementors = []string{"Query"}
12432
12433func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
12434	fields := graphql.CollectFields(ec.RequestContext, sel, queryImplementors)
12435
12436	ctx = graphql.WithResolverContext(ctx, &graphql.ResolverContext{
12437		Object: "Query",
12438	})
12439
12440	out := graphql.NewFieldSet(fields)
12441	var invalids uint32
12442	for i, field := range fields {
12443		switch field.Name {
12444		case "__typename":
12445			out.Values[i] = graphql.MarshalString("Query")
12446		case "defaultRepository":
12447			field := field
12448			out.Concurrently(i, func() (res graphql.Marshaler) {
12449				defer func() {
12450					if r := recover(); r != nil {
12451						ec.Error(ctx, ec.Recover(ctx, r))
12452					}
12453				}()
12454				res = ec._Query_defaultRepository(ctx, field)
12455				return res
12456			})
12457		case "repository":
12458			field := field
12459			out.Concurrently(i, func() (res graphql.Marshaler) {
12460				defer func() {
12461					if r := recover(); r != nil {
12462						ec.Error(ctx, ec.Recover(ctx, r))
12463					}
12464				}()
12465				res = ec._Query_repository(ctx, field)
12466				return res
12467			})
12468		case "__type":
12469			out.Values[i] = ec._Query___type(ctx, field)
12470		case "__schema":
12471			out.Values[i] = ec._Query___schema(ctx, field)
12472		default:
12473			panic("unknown field " + strconv.Quote(field.Name))
12474		}
12475	}
12476	out.Dispatch()
12477	if invalids > 0 {
12478		return graphql.Null
12479	}
12480	return out
12481}
12482
12483var repositoryImplementors = []string{"Repository"}
12484
12485func (ec *executionContext) _Repository(ctx context.Context, sel ast.SelectionSet, obj *models.Repository) graphql.Marshaler {
12486	fields := graphql.CollectFields(ec.RequestContext, sel, repositoryImplementors)
12487
12488	out := graphql.NewFieldSet(fields)
12489	var invalids uint32
12490	for i, field := range fields {
12491		switch field.Name {
12492		case "__typename":
12493			out.Values[i] = graphql.MarshalString("Repository")
12494		case "allBugs":
12495			field := field
12496			out.Concurrently(i, func() (res graphql.Marshaler) {
12497				defer func() {
12498					if r := recover(); r != nil {
12499						ec.Error(ctx, ec.Recover(ctx, r))
12500					}
12501				}()
12502				res = ec._Repository_allBugs(ctx, field, obj)
12503				if res == graphql.Null {
12504					atomic.AddUint32(&invalids, 1)
12505				}
12506				return res
12507			})
12508		case "bug":
12509			field := field
12510			out.Concurrently(i, func() (res graphql.Marshaler) {
12511				defer func() {
12512					if r := recover(); r != nil {
12513						ec.Error(ctx, ec.Recover(ctx, r))
12514					}
12515				}()
12516				res = ec._Repository_bug(ctx, field, obj)
12517				return res
12518			})
12519		case "allIdentities":
12520			field := field
12521			out.Concurrently(i, func() (res graphql.Marshaler) {
12522				defer func() {
12523					if r := recover(); r != nil {
12524						ec.Error(ctx, ec.Recover(ctx, r))
12525					}
12526				}()
12527				res = ec._Repository_allIdentities(ctx, field, obj)
12528				if res == graphql.Null {
12529					atomic.AddUint32(&invalids, 1)
12530				}
12531				return res
12532			})
12533		case "identity":
12534			field := field
12535			out.Concurrently(i, func() (res graphql.Marshaler) {
12536				defer func() {
12537					if r := recover(); r != nil {
12538						ec.Error(ctx, ec.Recover(ctx, r))
12539					}
12540				}()
12541				res = ec._Repository_identity(ctx, field, obj)
12542				return res
12543			})
12544		case "userIdentity":
12545			field := field
12546			out.Concurrently(i, func() (res graphql.Marshaler) {
12547				defer func() {
12548					if r := recover(); r != nil {
12549						ec.Error(ctx, ec.Recover(ctx, r))
12550					}
12551				}()
12552				res = ec._Repository_userIdentity(ctx, field, obj)
12553				return res
12554			})
12555		case "validLabels":
12556			field := field
12557			out.Concurrently(i, func() (res graphql.Marshaler) {
12558				defer func() {
12559					if r := recover(); r != nil {
12560						ec.Error(ctx, ec.Recover(ctx, r))
12561					}
12562				}()
12563				res = ec._Repository_validLabels(ctx, field, obj)
12564				if res == graphql.Null {
12565					atomic.AddUint32(&invalids, 1)
12566				}
12567				return res
12568			})
12569		default:
12570			panic("unknown field " + strconv.Quote(field.Name))
12571		}
12572	}
12573	out.Dispatch()
12574	if invalids > 0 {
12575		return graphql.Null
12576	}
12577	return out
12578}
12579
12580var setStatusOperationImplementors = []string{"SetStatusOperation", "Operation", "Authored"}
12581
12582func (ec *executionContext) _SetStatusOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.SetStatusOperation) graphql.Marshaler {
12583	fields := graphql.CollectFields(ec.RequestContext, sel, setStatusOperationImplementors)
12584
12585	out := graphql.NewFieldSet(fields)
12586	var invalids uint32
12587	for i, field := range fields {
12588		switch field.Name {
12589		case "__typename":
12590			out.Values[i] = graphql.MarshalString("SetStatusOperation")
12591		case "hash":
12592			out.Values[i] = ec._SetStatusOperation_hash(ctx, field, obj)
12593			if out.Values[i] == graphql.Null {
12594				atomic.AddUint32(&invalids, 1)
12595			}
12596		case "author":
12597			out.Values[i] = ec._SetStatusOperation_author(ctx, field, obj)
12598			if out.Values[i] == graphql.Null {
12599				atomic.AddUint32(&invalids, 1)
12600			}
12601		case "date":
12602			field := field
12603			out.Concurrently(i, func() (res graphql.Marshaler) {
12604				defer func() {
12605					if r := recover(); r != nil {
12606						ec.Error(ctx, ec.Recover(ctx, r))
12607					}
12608				}()
12609				res = ec._SetStatusOperation_date(ctx, field, obj)
12610				if res == graphql.Null {
12611					atomic.AddUint32(&invalids, 1)
12612				}
12613				return res
12614			})
12615		case "status":
12616			field := field
12617			out.Concurrently(i, func() (res graphql.Marshaler) {
12618				defer func() {
12619					if r := recover(); r != nil {
12620						ec.Error(ctx, ec.Recover(ctx, r))
12621					}
12622				}()
12623				res = ec._SetStatusOperation_status(ctx, field, obj)
12624				if res == graphql.Null {
12625					atomic.AddUint32(&invalids, 1)
12626				}
12627				return res
12628			})
12629		default:
12630			panic("unknown field " + strconv.Quote(field.Name))
12631		}
12632	}
12633	out.Dispatch()
12634	if invalids > 0 {
12635		return graphql.Null
12636	}
12637	return out
12638}
12639
12640var setStatusTimelineItemImplementors = []string{"SetStatusTimelineItem", "TimelineItem", "Authored"}
12641
12642func (ec *executionContext) _SetStatusTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.SetStatusTimelineItem) graphql.Marshaler {
12643	fields := graphql.CollectFields(ec.RequestContext, sel, setStatusTimelineItemImplementors)
12644
12645	out := graphql.NewFieldSet(fields)
12646	var invalids uint32
12647	for i, field := range fields {
12648		switch field.Name {
12649		case "__typename":
12650			out.Values[i] = graphql.MarshalString("SetStatusTimelineItem")
12651		case "hash":
12652			out.Values[i] = ec._SetStatusTimelineItem_hash(ctx, field, obj)
12653			if out.Values[i] == graphql.Null {
12654				atomic.AddUint32(&invalids, 1)
12655			}
12656		case "author":
12657			out.Values[i] = ec._SetStatusTimelineItem_author(ctx, field, obj)
12658			if out.Values[i] == graphql.Null {
12659				atomic.AddUint32(&invalids, 1)
12660			}
12661		case "date":
12662			field := field
12663			out.Concurrently(i, func() (res graphql.Marshaler) {
12664				defer func() {
12665					if r := recover(); r != nil {
12666						ec.Error(ctx, ec.Recover(ctx, r))
12667					}
12668				}()
12669				res = ec._SetStatusTimelineItem_date(ctx, field, obj)
12670				if res == graphql.Null {
12671					atomic.AddUint32(&invalids, 1)
12672				}
12673				return res
12674			})
12675		case "status":
12676			field := field
12677			out.Concurrently(i, func() (res graphql.Marshaler) {
12678				defer func() {
12679					if r := recover(); r != nil {
12680						ec.Error(ctx, ec.Recover(ctx, r))
12681					}
12682				}()
12683				res = ec._SetStatusTimelineItem_status(ctx, field, obj)
12684				if res == graphql.Null {
12685					atomic.AddUint32(&invalids, 1)
12686				}
12687				return res
12688			})
12689		default:
12690			panic("unknown field " + strconv.Quote(field.Name))
12691		}
12692	}
12693	out.Dispatch()
12694	if invalids > 0 {
12695		return graphql.Null
12696	}
12697	return out
12698}
12699
12700var setTitleOperationImplementors = []string{"SetTitleOperation", "Operation", "Authored"}
12701
12702func (ec *executionContext) _SetTitleOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.SetTitleOperation) graphql.Marshaler {
12703	fields := graphql.CollectFields(ec.RequestContext, sel, setTitleOperationImplementors)
12704
12705	out := graphql.NewFieldSet(fields)
12706	var invalids uint32
12707	for i, field := range fields {
12708		switch field.Name {
12709		case "__typename":
12710			out.Values[i] = graphql.MarshalString("SetTitleOperation")
12711		case "hash":
12712			out.Values[i] = ec._SetTitleOperation_hash(ctx, field, obj)
12713			if out.Values[i] == graphql.Null {
12714				atomic.AddUint32(&invalids, 1)
12715			}
12716		case "author":
12717			out.Values[i] = ec._SetTitleOperation_author(ctx, field, obj)
12718			if out.Values[i] == graphql.Null {
12719				atomic.AddUint32(&invalids, 1)
12720			}
12721		case "date":
12722			field := field
12723			out.Concurrently(i, func() (res graphql.Marshaler) {
12724				defer func() {
12725					if r := recover(); r != nil {
12726						ec.Error(ctx, ec.Recover(ctx, r))
12727					}
12728				}()
12729				res = ec._SetTitleOperation_date(ctx, field, obj)
12730				if res == graphql.Null {
12731					atomic.AddUint32(&invalids, 1)
12732				}
12733				return res
12734			})
12735		case "title":
12736			out.Values[i] = ec._SetTitleOperation_title(ctx, field, obj)
12737			if out.Values[i] == graphql.Null {
12738				atomic.AddUint32(&invalids, 1)
12739			}
12740		case "was":
12741			out.Values[i] = ec._SetTitleOperation_was(ctx, field, obj)
12742			if out.Values[i] == graphql.Null {
12743				atomic.AddUint32(&invalids, 1)
12744			}
12745		default:
12746			panic("unknown field " + strconv.Quote(field.Name))
12747		}
12748	}
12749	out.Dispatch()
12750	if invalids > 0 {
12751		return graphql.Null
12752	}
12753	return out
12754}
12755
12756var setTitlePayloadImplementors = []string{"SetTitlePayload"}
12757
12758func (ec *executionContext) _SetTitlePayload(ctx context.Context, sel ast.SelectionSet, obj *models.SetTitlePayload) graphql.Marshaler {
12759	fields := graphql.CollectFields(ec.RequestContext, sel, setTitlePayloadImplementors)
12760
12761	out := graphql.NewFieldSet(fields)
12762	var invalids uint32
12763	for i, field := range fields {
12764		switch field.Name {
12765		case "__typename":
12766			out.Values[i] = graphql.MarshalString("SetTitlePayload")
12767		case "clientMutationId":
12768			out.Values[i] = ec._SetTitlePayload_clientMutationId(ctx, field, obj)
12769		case "bug":
12770			out.Values[i] = ec._SetTitlePayload_bug(ctx, field, obj)
12771			if out.Values[i] == graphql.Null {
12772				invalids++
12773			}
12774		case "operation":
12775			out.Values[i] = ec._SetTitlePayload_operation(ctx, field, obj)
12776			if out.Values[i] == graphql.Null {
12777				invalids++
12778			}
12779		default:
12780			panic("unknown field " + strconv.Quote(field.Name))
12781		}
12782	}
12783	out.Dispatch()
12784	if invalids > 0 {
12785		return graphql.Null
12786	}
12787	return out
12788}
12789
12790var setTitleTimelineItemImplementors = []string{"SetTitleTimelineItem", "TimelineItem", "Authored"}
12791
12792func (ec *executionContext) _SetTitleTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.SetTitleTimelineItem) graphql.Marshaler {
12793	fields := graphql.CollectFields(ec.RequestContext, sel, setTitleTimelineItemImplementors)
12794
12795	out := graphql.NewFieldSet(fields)
12796	var invalids uint32
12797	for i, field := range fields {
12798		switch field.Name {
12799		case "__typename":
12800			out.Values[i] = graphql.MarshalString("SetTitleTimelineItem")
12801		case "hash":
12802			out.Values[i] = ec._SetTitleTimelineItem_hash(ctx, field, obj)
12803			if out.Values[i] == graphql.Null {
12804				atomic.AddUint32(&invalids, 1)
12805			}
12806		case "author":
12807			out.Values[i] = ec._SetTitleTimelineItem_author(ctx, field, obj)
12808			if out.Values[i] == graphql.Null {
12809				atomic.AddUint32(&invalids, 1)
12810			}
12811		case "date":
12812			field := field
12813			out.Concurrently(i, func() (res graphql.Marshaler) {
12814				defer func() {
12815					if r := recover(); r != nil {
12816						ec.Error(ctx, ec.Recover(ctx, r))
12817					}
12818				}()
12819				res = ec._SetTitleTimelineItem_date(ctx, field, obj)
12820				if res == graphql.Null {
12821					atomic.AddUint32(&invalids, 1)
12822				}
12823				return res
12824			})
12825		case "title":
12826			out.Values[i] = ec._SetTitleTimelineItem_title(ctx, field, obj)
12827			if out.Values[i] == graphql.Null {
12828				atomic.AddUint32(&invalids, 1)
12829			}
12830		case "was":
12831			out.Values[i] = ec._SetTitleTimelineItem_was(ctx, field, obj)
12832			if out.Values[i] == graphql.Null {
12833				atomic.AddUint32(&invalids, 1)
12834			}
12835		default:
12836			panic("unknown field " + strconv.Quote(field.Name))
12837		}
12838	}
12839	out.Dispatch()
12840	if invalids > 0 {
12841		return graphql.Null
12842	}
12843	return out
12844}
12845
12846var timelineItemConnectionImplementors = []string{"TimelineItemConnection"}
12847
12848func (ec *executionContext) _TimelineItemConnection(ctx context.Context, sel ast.SelectionSet, obj *models.TimelineItemConnection) graphql.Marshaler {
12849	fields := graphql.CollectFields(ec.RequestContext, sel, timelineItemConnectionImplementors)
12850
12851	out := graphql.NewFieldSet(fields)
12852	var invalids uint32
12853	for i, field := range fields {
12854		switch field.Name {
12855		case "__typename":
12856			out.Values[i] = graphql.MarshalString("TimelineItemConnection")
12857		case "edges":
12858			out.Values[i] = ec._TimelineItemConnection_edges(ctx, field, obj)
12859			if out.Values[i] == graphql.Null {
12860				invalids++
12861			}
12862		case "nodes":
12863			out.Values[i] = ec._TimelineItemConnection_nodes(ctx, field, obj)
12864			if out.Values[i] == graphql.Null {
12865				invalids++
12866			}
12867		case "pageInfo":
12868			out.Values[i] = ec._TimelineItemConnection_pageInfo(ctx, field, obj)
12869			if out.Values[i] == graphql.Null {
12870				invalids++
12871			}
12872		case "totalCount":
12873			out.Values[i] = ec._TimelineItemConnection_totalCount(ctx, field, obj)
12874			if out.Values[i] == graphql.Null {
12875				invalids++
12876			}
12877		default:
12878			panic("unknown field " + strconv.Quote(field.Name))
12879		}
12880	}
12881	out.Dispatch()
12882	if invalids > 0 {
12883		return graphql.Null
12884	}
12885	return out
12886}
12887
12888var timelineItemEdgeImplementors = []string{"TimelineItemEdge"}
12889
12890func (ec *executionContext) _TimelineItemEdge(ctx context.Context, sel ast.SelectionSet, obj *models.TimelineItemEdge) graphql.Marshaler {
12891	fields := graphql.CollectFields(ec.RequestContext, sel, timelineItemEdgeImplementors)
12892
12893	out := graphql.NewFieldSet(fields)
12894	var invalids uint32
12895	for i, field := range fields {
12896		switch field.Name {
12897		case "__typename":
12898			out.Values[i] = graphql.MarshalString("TimelineItemEdge")
12899		case "cursor":
12900			out.Values[i] = ec._TimelineItemEdge_cursor(ctx, field, obj)
12901			if out.Values[i] == graphql.Null {
12902				invalids++
12903			}
12904		case "node":
12905			out.Values[i] = ec._TimelineItemEdge_node(ctx, field, obj)
12906			if out.Values[i] == graphql.Null {
12907				invalids++
12908			}
12909		default:
12910			panic("unknown field " + strconv.Quote(field.Name))
12911		}
12912	}
12913	out.Dispatch()
12914	if invalids > 0 {
12915		return graphql.Null
12916	}
12917	return out
12918}
12919
12920var __DirectiveImplementors = []string{"__Directive"}
12921
12922func (ec *executionContext) ___Directive(ctx context.Context, sel ast.SelectionSet, obj *introspection.Directive) graphql.Marshaler {
12923	fields := graphql.CollectFields(ec.RequestContext, sel, __DirectiveImplementors)
12924
12925	out := graphql.NewFieldSet(fields)
12926	var invalids uint32
12927	for i, field := range fields {
12928		switch field.Name {
12929		case "__typename":
12930			out.Values[i] = graphql.MarshalString("__Directive")
12931		case "name":
12932			out.Values[i] = ec.___Directive_name(ctx, field, obj)
12933			if out.Values[i] == graphql.Null {
12934				invalids++
12935			}
12936		case "description":
12937			out.Values[i] = ec.___Directive_description(ctx, field, obj)
12938		case "locations":
12939			out.Values[i] = ec.___Directive_locations(ctx, field, obj)
12940			if out.Values[i] == graphql.Null {
12941				invalids++
12942			}
12943		case "args":
12944			out.Values[i] = ec.___Directive_args(ctx, field, obj)
12945			if out.Values[i] == graphql.Null {
12946				invalids++
12947			}
12948		default:
12949			panic("unknown field " + strconv.Quote(field.Name))
12950		}
12951	}
12952	out.Dispatch()
12953	if invalids > 0 {
12954		return graphql.Null
12955	}
12956	return out
12957}
12958
12959var __EnumValueImplementors = []string{"__EnumValue"}
12960
12961func (ec *executionContext) ___EnumValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.EnumValue) graphql.Marshaler {
12962	fields := graphql.CollectFields(ec.RequestContext, sel, __EnumValueImplementors)
12963
12964	out := graphql.NewFieldSet(fields)
12965	var invalids uint32
12966	for i, field := range fields {
12967		switch field.Name {
12968		case "__typename":
12969			out.Values[i] = graphql.MarshalString("__EnumValue")
12970		case "name":
12971			out.Values[i] = ec.___EnumValue_name(ctx, field, obj)
12972			if out.Values[i] == graphql.Null {
12973				invalids++
12974			}
12975		case "description":
12976			out.Values[i] = ec.___EnumValue_description(ctx, field, obj)
12977		case "isDeprecated":
12978			out.Values[i] = ec.___EnumValue_isDeprecated(ctx, field, obj)
12979			if out.Values[i] == graphql.Null {
12980				invalids++
12981			}
12982		case "deprecationReason":
12983			out.Values[i] = ec.___EnumValue_deprecationReason(ctx, field, obj)
12984		default:
12985			panic("unknown field " + strconv.Quote(field.Name))
12986		}
12987	}
12988	out.Dispatch()
12989	if invalids > 0 {
12990		return graphql.Null
12991	}
12992	return out
12993}
12994
12995var __FieldImplementors = []string{"__Field"}
12996
12997func (ec *executionContext) ___Field(ctx context.Context, sel ast.SelectionSet, obj *introspection.Field) graphql.Marshaler {
12998	fields := graphql.CollectFields(ec.RequestContext, sel, __FieldImplementors)
12999
13000	out := graphql.NewFieldSet(fields)
13001	var invalids uint32
13002	for i, field := range fields {
13003		switch field.Name {
13004		case "__typename":
13005			out.Values[i] = graphql.MarshalString("__Field")
13006		case "name":
13007			out.Values[i] = ec.___Field_name(ctx, field, obj)
13008			if out.Values[i] == graphql.Null {
13009				invalids++
13010			}
13011		case "description":
13012			out.Values[i] = ec.___Field_description(ctx, field, obj)
13013		case "args":
13014			out.Values[i] = ec.___Field_args(ctx, field, obj)
13015			if out.Values[i] == graphql.Null {
13016				invalids++
13017			}
13018		case "type":
13019			out.Values[i] = ec.___Field_type(ctx, field, obj)
13020			if out.Values[i] == graphql.Null {
13021				invalids++
13022			}
13023		case "isDeprecated":
13024			out.Values[i] = ec.___Field_isDeprecated(ctx, field, obj)
13025			if out.Values[i] == graphql.Null {
13026				invalids++
13027			}
13028		case "deprecationReason":
13029			out.Values[i] = ec.___Field_deprecationReason(ctx, field, obj)
13030		default:
13031			panic("unknown field " + strconv.Quote(field.Name))
13032		}
13033	}
13034	out.Dispatch()
13035	if invalids > 0 {
13036		return graphql.Null
13037	}
13038	return out
13039}
13040
13041var __InputValueImplementors = []string{"__InputValue"}
13042
13043func (ec *executionContext) ___InputValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.InputValue) graphql.Marshaler {
13044	fields := graphql.CollectFields(ec.RequestContext, sel, __InputValueImplementors)
13045
13046	out := graphql.NewFieldSet(fields)
13047	var invalids uint32
13048	for i, field := range fields {
13049		switch field.Name {
13050		case "__typename":
13051			out.Values[i] = graphql.MarshalString("__InputValue")
13052		case "name":
13053			out.Values[i] = ec.___InputValue_name(ctx, field, obj)
13054			if out.Values[i] == graphql.Null {
13055				invalids++
13056			}
13057		case "description":
13058			out.Values[i] = ec.___InputValue_description(ctx, field, obj)
13059		case "type":
13060			out.Values[i] = ec.___InputValue_type(ctx, field, obj)
13061			if out.Values[i] == graphql.Null {
13062				invalids++
13063			}
13064		case "defaultValue":
13065			out.Values[i] = ec.___InputValue_defaultValue(ctx, field, obj)
13066		default:
13067			panic("unknown field " + strconv.Quote(field.Name))
13068		}
13069	}
13070	out.Dispatch()
13071	if invalids > 0 {
13072		return graphql.Null
13073	}
13074	return out
13075}
13076
13077var __SchemaImplementors = []string{"__Schema"}
13078
13079func (ec *executionContext) ___Schema(ctx context.Context, sel ast.SelectionSet, obj *introspection.Schema) graphql.Marshaler {
13080	fields := graphql.CollectFields(ec.RequestContext, sel, __SchemaImplementors)
13081
13082	out := graphql.NewFieldSet(fields)
13083	var invalids uint32
13084	for i, field := range fields {
13085		switch field.Name {
13086		case "__typename":
13087			out.Values[i] = graphql.MarshalString("__Schema")
13088		case "types":
13089			out.Values[i] = ec.___Schema_types(ctx, field, obj)
13090			if out.Values[i] == graphql.Null {
13091				invalids++
13092			}
13093		case "queryType":
13094			out.Values[i] = ec.___Schema_queryType(ctx, field, obj)
13095			if out.Values[i] == graphql.Null {
13096				invalids++
13097			}
13098		case "mutationType":
13099			out.Values[i] = ec.___Schema_mutationType(ctx, field, obj)
13100		case "subscriptionType":
13101			out.Values[i] = ec.___Schema_subscriptionType(ctx, field, obj)
13102		case "directives":
13103			out.Values[i] = ec.___Schema_directives(ctx, field, obj)
13104			if out.Values[i] == graphql.Null {
13105				invalids++
13106			}
13107		default:
13108			panic("unknown field " + strconv.Quote(field.Name))
13109		}
13110	}
13111	out.Dispatch()
13112	if invalids > 0 {
13113		return graphql.Null
13114	}
13115	return out
13116}
13117
13118var __TypeImplementors = []string{"__Type"}
13119
13120func (ec *executionContext) ___Type(ctx context.Context, sel ast.SelectionSet, obj *introspection.Type) graphql.Marshaler {
13121	fields := graphql.CollectFields(ec.RequestContext, sel, __TypeImplementors)
13122
13123	out := graphql.NewFieldSet(fields)
13124	var invalids uint32
13125	for i, field := range fields {
13126		switch field.Name {
13127		case "__typename":
13128			out.Values[i] = graphql.MarshalString("__Type")
13129		case "kind":
13130			out.Values[i] = ec.___Type_kind(ctx, field, obj)
13131			if out.Values[i] == graphql.Null {
13132				invalids++
13133			}
13134		case "name":
13135			out.Values[i] = ec.___Type_name(ctx, field, obj)
13136		case "description":
13137			out.Values[i] = ec.___Type_description(ctx, field, obj)
13138		case "fields":
13139			out.Values[i] = ec.___Type_fields(ctx, field, obj)
13140		case "interfaces":
13141			out.Values[i] = ec.___Type_interfaces(ctx, field, obj)
13142		case "possibleTypes":
13143			out.Values[i] = ec.___Type_possibleTypes(ctx, field, obj)
13144		case "enumValues":
13145			out.Values[i] = ec.___Type_enumValues(ctx, field, obj)
13146		case "inputFields":
13147			out.Values[i] = ec.___Type_inputFields(ctx, field, obj)
13148		case "ofType":
13149			out.Values[i] = ec.___Type_ofType(ctx, field, obj)
13150		default:
13151			panic("unknown field " + strconv.Quote(field.Name))
13152		}
13153	}
13154	out.Dispatch()
13155	if invalids > 0 {
13156		return graphql.Null
13157	}
13158	return out
13159}
13160
13161// endregion **************************** object.gotpl ****************************
13162
13163// region    ***************************** type.gotpl *****************************
13164
13165func (ec *executionContext) unmarshalNAddCommentInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentInput(ctx context.Context, v interface{}) (models.AddCommentInput, error) {
13166	return ec.unmarshalInputAddCommentInput(ctx, v)
13167}
13168
13169func (ec *executionContext) marshalNAddCommentOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx context.Context, sel ast.SelectionSet, v bug.AddCommentOperation) graphql.Marshaler {
13170	return ec._AddCommentOperation(ctx, sel, &v)
13171}
13172
13173func (ec *executionContext) marshalNAddCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx context.Context, sel ast.SelectionSet, v *bug.AddCommentOperation) graphql.Marshaler {
13174	if v == nil {
13175		if !ec.HasError(graphql.GetResolverContext(ctx)) {
13176			ec.Errorf(ctx, "must not be null")
13177		}
13178		return graphql.Null
13179	}
13180	return ec._AddCommentOperation(ctx, sel, v)
13181}
13182
13183func (ec *executionContext) marshalNAddCommentPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx context.Context, sel ast.SelectionSet, v models.AddCommentPayload) graphql.Marshaler {
13184	return ec._AddCommentPayload(ctx, sel, &v)
13185}
13186
13187func (ec *executionContext) marshalNAddCommentPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx context.Context, sel ast.SelectionSet, v *models.AddCommentPayload) graphql.Marshaler {
13188	if v == nil {
13189		if !ec.HasError(graphql.GetResolverContext(ctx)) {
13190			ec.Errorf(ctx, "must not be null")
13191		}
13192		return graphql.Null
13193	}
13194	return ec._AddCommentPayload(ctx, sel, v)
13195}
13196
13197func (ec *executionContext) unmarshalNBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
13198	return graphql.UnmarshalBoolean(v)
13199}
13200
13201func (ec *executionContext) marshalNBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
13202	res := graphql.MarshalBoolean(v)
13203	if res == graphql.Null {
13204		if !ec.HasError(graphql.GetResolverContext(ctx)) {
13205			ec.Errorf(ctx, "must not be null")
13206		}
13207	}
13208	return res
13209}
13210
13211func (ec *executionContext) marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx context.Context, sel ast.SelectionSet, v bug.Snapshot) graphql.Marshaler {
13212	return ec._Bug(ctx, sel, &v)
13213}
13214
13215func (ec *executionContext) marshalNBug2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx context.Context, sel ast.SelectionSet, v []*bug.Snapshot) graphql.Marshaler {
13216	ret := make(graphql.Array, len(v))
13217	var wg sync.WaitGroup
13218	isLen1 := len(v) == 1
13219	if !isLen1 {
13220		wg.Add(len(v))
13221	}
13222	for i := range v {
13223		i := i
13224		rctx := &graphql.ResolverContext{
13225			Index:  &i,
13226			Result: &v[i],
13227		}
13228		ctx := graphql.WithResolverContext(ctx, rctx)
13229		f := func(i int) {
13230			defer func() {
13231				if r := recover(); r != nil {
13232					ec.Error(ctx, ec.Recover(ctx, r))
13233					ret = nil
13234				}
13235			}()
13236			if !isLen1 {
13237				defer wg.Done()
13238			}
13239			ret[i] = ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, sel, v[i])
13240		}
13241		if isLen1 {
13242			f(i)
13243		} else {
13244			go f(i)
13245		}
13246
13247	}
13248	wg.Wait()
13249	return ret
13250}
13251
13252func (ec *executionContext) marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx context.Context, sel ast.SelectionSet, v *bug.Snapshot) graphql.Marshaler {
13253	if v == nil {
13254		if !ec.HasError(graphql.GetResolverContext(ctx)) {
13255			ec.Errorf(ctx, "must not be null")
13256		}
13257		return graphql.Null
13258	}
13259	return ec._Bug(ctx, sel, v)
13260}
13261
13262func (ec *executionContext) marshalNBugConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugConnection(ctx context.Context, sel ast.SelectionSet, v models.BugConnection) graphql.Marshaler {
13263	return ec._BugConnection(ctx, sel, &v)
13264}
13265
13266func (ec *executionContext) marshalNBugConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugConnection(ctx context.Context, sel ast.SelectionSet, v *models.BugConnection) graphql.Marshaler {
13267	if v == nil {
13268		if !ec.HasError(graphql.GetResolverContext(ctx)) {
13269			ec.Errorf(ctx, "must not be null")
13270		}
13271		return graphql.Null
13272	}
13273	return ec._BugConnection(ctx, sel, v)
13274}
13275
13276func (ec *executionContext) marshalNBugEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx context.Context, sel ast.SelectionSet, v models.BugEdge) graphql.Marshaler {
13277	return ec._BugEdge(ctx, sel, &v)
13278}
13279
13280func (ec *executionContext) marshalNBugEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx context.Context, sel ast.SelectionSet, v []*models.BugEdge) graphql.Marshaler {
13281	ret := make(graphql.Array, len(v))
13282	var wg sync.WaitGroup
13283	isLen1 := len(v) == 1
13284	if !isLen1 {
13285		wg.Add(len(v))
13286	}
13287	for i := range v {
13288		i := i
13289		rctx := &graphql.ResolverContext{
13290			Index:  &i,
13291			Result: &v[i],
13292		}
13293		ctx := graphql.WithResolverContext(ctx, rctx)
13294		f := func(i int) {
13295			defer func() {
13296				if r := recover(); r != nil {
13297					ec.Error(ctx, ec.Recover(ctx, r))
13298					ret = nil
13299				}
13300			}()
13301			if !isLen1 {
13302				defer wg.Done()
13303			}
13304			ret[i] = ec.marshalNBugEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx, sel, v[i])
13305		}
13306		if isLen1 {
13307			f(i)
13308		} else {
13309			go f(i)
13310		}
13311
13312	}
13313	wg.Wait()
13314	return ret
13315}
13316
13317func (ec *executionContext) marshalNBugEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx context.Context, sel ast.SelectionSet, v *models.BugEdge) graphql.Marshaler {
13318	if v == nil {
13319		if !ec.HasError(graphql.GetResolverContext(ctx)) {
13320			ec.Errorf(ctx, "must not be null")
13321		}
13322		return graphql.Null
13323	}
13324	return ec._BugEdge(ctx, sel, v)
13325}
13326
13327func (ec *executionContext) marshalNChangeLabelPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, v models.ChangeLabelPayload) graphql.Marshaler {
13328	return ec._ChangeLabelPayload(ctx, sel, &v)
13329}
13330
13331func (ec *executionContext) marshalNChangeLabelPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, v *models.ChangeLabelPayload) graphql.Marshaler {
13332	if v == nil {
13333		if !ec.HasError(graphql.GetResolverContext(ctx)) {
13334			ec.Errorf(ctx, "must not be null")
13335		}
13336		return graphql.Null
13337	}
13338	return ec._ChangeLabelPayload(ctx, sel, v)
13339}
13340
13341func (ec *executionContext) unmarshalNCloseBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugInput(ctx context.Context, v interface{}) (models.CloseBugInput, error) {
13342	return ec.unmarshalInputCloseBugInput(ctx, v)
13343}
13344
13345func (ec *executionContext) marshalNCloseBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx context.Context, sel ast.SelectionSet, v models.CloseBugPayload) graphql.Marshaler {
13346	return ec._CloseBugPayload(ctx, sel, &v)
13347}
13348
13349func (ec *executionContext) marshalNCloseBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.CloseBugPayload) graphql.Marshaler {
13350	if v == nil {
13351		if !ec.HasError(graphql.GetResolverContext(ctx)) {
13352			ec.Errorf(ctx, "must not be null")
13353		}
13354		return graphql.Null
13355	}
13356	return ec._CloseBugPayload(ctx, sel, v)
13357}
13358
13359func (ec *executionContext) marshalNColor2imageᚋcolorᚐRGBA(ctx context.Context, sel ast.SelectionSet, v color.RGBA) graphql.Marshaler {
13360	return ec._Color(ctx, sel, &v)
13361}
13362
13363func (ec *executionContext) marshalNColor2ᚖimageᚋcolorᚐRGBA(ctx context.Context, sel ast.SelectionSet, v *color.RGBA) graphql.Marshaler {
13364	if v == nil {
13365		if !ec.HasError(graphql.GetResolverContext(ctx)) {
13366			ec.Errorf(ctx, "must not be null")
13367		}
13368		return graphql.Null
13369	}
13370	return ec._Color(ctx, sel, v)
13371}
13372
13373func (ec *executionContext) marshalNComment2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx context.Context, sel ast.SelectionSet, v bug.Comment) graphql.Marshaler {
13374	return ec._Comment(ctx, sel, &v)
13375}
13376
13377func (ec *executionContext) marshalNComment2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx context.Context, sel ast.SelectionSet, v []*bug.Comment) graphql.Marshaler {
13378	ret := make(graphql.Array, len(v))
13379	var wg sync.WaitGroup
13380	isLen1 := len(v) == 1
13381	if !isLen1 {
13382		wg.Add(len(v))
13383	}
13384	for i := range v {
13385		i := i
13386		rctx := &graphql.ResolverContext{
13387			Index:  &i,
13388			Result: &v[i],
13389		}
13390		ctx := graphql.WithResolverContext(ctx, rctx)
13391		f := func(i int) {
13392			defer func() {
13393				if r := recover(); r != nil {
13394					ec.Error(ctx, ec.Recover(ctx, r))
13395					ret = nil
13396				}
13397			}()
13398			if !isLen1 {
13399				defer wg.Done()
13400			}
13401			ret[i] = ec.marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx, sel, v[i])
13402		}
13403		if isLen1 {
13404			f(i)
13405		} else {
13406			go f(i)
13407		}
13408
13409	}
13410	wg.Wait()
13411	return ret
13412}
13413
13414func (ec *executionContext) marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx context.Context, sel ast.SelectionSet, v *bug.Comment) graphql.Marshaler {
13415	if v == nil {
13416		if !ec.HasError(graphql.GetResolverContext(ctx)) {
13417			ec.Errorf(ctx, "must not be null")
13418		}
13419		return graphql.Null
13420	}
13421	return ec._Comment(ctx, sel, v)
13422}
13423
13424func (ec *executionContext) marshalNCommentConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentConnection(ctx context.Context, sel ast.SelectionSet, v models.CommentConnection) graphql.Marshaler {
13425	return ec._CommentConnection(ctx, sel, &v)
13426}
13427
13428func (ec *executionContext) marshalNCommentConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentConnection(ctx context.Context, sel ast.SelectionSet, v *models.CommentConnection) graphql.Marshaler {
13429	if v == nil {
13430		if !ec.HasError(graphql.GetResolverContext(ctx)) {
13431			ec.Errorf(ctx, "must not be null")
13432		}
13433		return graphql.Null
13434	}
13435	return ec._CommentConnection(ctx, sel, v)
13436}
13437
13438func (ec *executionContext) marshalNCommentEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx context.Context, sel ast.SelectionSet, v models.CommentEdge) graphql.Marshaler {
13439	return ec._CommentEdge(ctx, sel, &v)
13440}
13441
13442func (ec *executionContext) marshalNCommentEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx context.Context, sel ast.SelectionSet, v []*models.CommentEdge) graphql.Marshaler {
13443	ret := make(graphql.Array, len(v))
13444	var wg sync.WaitGroup
13445	isLen1 := len(v) == 1
13446	if !isLen1 {
13447		wg.Add(len(v))
13448	}
13449	for i := range v {
13450		i := i
13451		rctx := &graphql.ResolverContext{
13452			Index:  &i,
13453			Result: &v[i],
13454		}
13455		ctx := graphql.WithResolverContext(ctx, rctx)
13456		f := func(i int) {
13457			defer func() {
13458				if r := recover(); r != nil {
13459					ec.Error(ctx, ec.Recover(ctx, r))
13460					ret = nil
13461				}
13462			}()
13463			if !isLen1 {
13464				defer wg.Done()
13465			}
13466			ret[i] = ec.marshalNCommentEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx, sel, v[i])
13467		}
13468		if isLen1 {
13469			f(i)
13470		} else {
13471			go f(i)
13472		}
13473
13474	}
13475	wg.Wait()
13476	return ret
13477}
13478
13479func (ec *executionContext) marshalNCommentEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx context.Context, sel ast.SelectionSet, v *models.CommentEdge) graphql.Marshaler {
13480	if v == nil {
13481		if !ec.HasError(graphql.GetResolverContext(ctx)) {
13482			ec.Errorf(ctx, "must not be null")
13483		}
13484		return graphql.Null
13485	}
13486	return ec._CommentEdge(ctx, sel, v)
13487}
13488
13489func (ec *executionContext) marshalNCommentHistoryStep2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx context.Context, sel ast.SelectionSet, v bug.CommentHistoryStep) graphql.Marshaler {
13490	return ec._CommentHistoryStep(ctx, sel, &v)
13491}
13492
13493func (ec *executionContext) marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx context.Context, sel ast.SelectionSet, v []bug.CommentHistoryStep) graphql.Marshaler {
13494	ret := make(graphql.Array, len(v))
13495	var wg sync.WaitGroup
13496	isLen1 := len(v) == 1
13497	if !isLen1 {
13498		wg.Add(len(v))
13499	}
13500	for i := range v {
13501		i := i
13502		rctx := &graphql.ResolverContext{
13503			Index:  &i,
13504			Result: &v[i],
13505		}
13506		ctx := graphql.WithResolverContext(ctx, rctx)
13507		f := func(i int) {
13508			defer func() {
13509				if r := recover(); r != nil {
13510					ec.Error(ctx, ec.Recover(ctx, r))
13511					ret = nil
13512				}
13513			}()
13514			if !isLen1 {
13515				defer wg.Done()
13516			}
13517			ret[i] = ec.marshalNCommentHistoryStep2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx, sel, v[i])
13518		}
13519		if isLen1 {
13520			f(i)
13521		} else {
13522			go f(i)
13523		}
13524
13525	}
13526	wg.Wait()
13527	return ret
13528}
13529
13530func (ec *executionContext) unmarshalNCommitAsNeededInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitAsNeededInput(ctx context.Context, v interface{}) (models.CommitAsNeededInput, error) {
13531	return ec.unmarshalInputCommitAsNeededInput(ctx, v)
13532}
13533
13534func (ec *executionContext) marshalNCommitAsNeededPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitAsNeededPayload(ctx context.Context, sel ast.SelectionSet, v models.CommitAsNeededPayload) graphql.Marshaler {
13535	return ec._CommitAsNeededPayload(ctx, sel, &v)
13536}
13537
13538func (ec *executionContext) marshalNCommitAsNeededPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitAsNeededPayload(ctx context.Context, sel ast.SelectionSet, v *models.CommitAsNeededPayload) graphql.Marshaler {
13539	if v == nil {
13540		if !ec.HasError(graphql.GetResolverContext(ctx)) {
13541			ec.Errorf(ctx, "must not be null")
13542		}
13543		return graphql.Null
13544	}
13545	return ec._CommitAsNeededPayload(ctx, sel, v)
13546}
13547
13548func (ec *executionContext) unmarshalNCommitInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitInput(ctx context.Context, v interface{}) (models.CommitInput, error) {
13549	return ec.unmarshalInputCommitInput(ctx, v)
13550}
13551
13552func (ec *executionContext) marshalNCommitPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitPayload(ctx context.Context, sel ast.SelectionSet, v models.CommitPayload) graphql.Marshaler {
13553	return ec._CommitPayload(ctx, sel, &v)
13554}
13555
13556func (ec *executionContext) marshalNCommitPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitPayload(ctx context.Context, sel ast.SelectionSet, v *models.CommitPayload) graphql.Marshaler {
13557	if v == nil {
13558		if !ec.HasError(graphql.GetResolverContext(ctx)) {
13559			ec.Errorf(ctx, "must not be null")
13560		}
13561		return graphql.Null
13562	}
13563	return ec._CommitPayload(ctx, sel, v)
13564}
13565
13566func (ec *executionContext) marshalNCreateOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCreateOperation(ctx context.Context, sel ast.SelectionSet, v bug.CreateOperation) graphql.Marshaler {
13567	return ec._CreateOperation(ctx, sel, &v)
13568}
13569
13570func (ec *executionContext) marshalNCreateOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCreateOperation(ctx context.Context, sel ast.SelectionSet, v *bug.CreateOperation) graphql.Marshaler {
13571	if v == nil {
13572		if !ec.HasError(graphql.GetResolverContext(ctx)) {
13573			ec.Errorf(ctx, "must not be null")
13574		}
13575		return graphql.Null
13576	}
13577	return ec._CreateOperation(ctx, sel, v)
13578}
13579
13580func (ec *executionContext) unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx context.Context, v interface{}) (git.Hash, error) {
13581	var res git.Hash
13582	return res, res.UnmarshalGQL(v)
13583}
13584
13585func (ec *executionContext) marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx context.Context, sel ast.SelectionSet, v git.Hash) graphql.Marshaler {
13586	return v
13587}
13588
13589func (ec *executionContext) unmarshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx context.Context, v interface{}) ([]git.Hash, error) {
13590	var vSlice []interface{}
13591	if v != nil {
13592		if tmp1, ok := v.([]interface{}); ok {
13593			vSlice = tmp1
13594		} else {
13595			vSlice = []interface{}{v}
13596		}
13597	}
13598	var err error
13599	res := make([]git.Hash, len(vSlice))
13600	for i := range vSlice {
13601		res[i], err = ec.unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, vSlice[i])
13602		if err != nil {
13603			return nil, err
13604		}
13605	}
13606	return res, nil
13607}
13608
13609func (ec *executionContext) marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx context.Context, sel ast.SelectionSet, v []git.Hash) graphql.Marshaler {
13610	ret := make(graphql.Array, len(v))
13611	for i := range v {
13612		ret[i] = ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, sel, v[i])
13613	}
13614
13615	return ret
13616}
13617
13618func (ec *executionContext) marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx context.Context, sel ast.SelectionSet, v identity.Interface) graphql.Marshaler {
13619	return ec._Identity(ctx, sel, &v)
13620}
13621
13622func (ec *executionContext) marshalNIdentity2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx context.Context, sel ast.SelectionSet, v []identity.Interface) graphql.Marshaler {
13623	ret := make(graphql.Array, len(v))
13624	var wg sync.WaitGroup
13625	isLen1 := len(v) == 1
13626	if !isLen1 {
13627		wg.Add(len(v))
13628	}
13629	for i := range v {
13630		i := i
13631		rctx := &graphql.ResolverContext{
13632			Index:  &i,
13633			Result: &v[i],
13634		}
13635		ctx := graphql.WithResolverContext(ctx, rctx)
13636		f := func(i int) {
13637			defer func() {
13638				if r := recover(); r != nil {
13639					ec.Error(ctx, ec.Recover(ctx, r))
13640					ret = nil
13641				}
13642			}()
13643			if !isLen1 {
13644				defer wg.Done()
13645			}
13646			ret[i] = ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, sel, v[i])
13647		}
13648		if isLen1 {
13649			f(i)
13650		} else {
13651			go f(i)
13652		}
13653
13654	}
13655	wg.Wait()
13656	return ret
13657}
13658
13659func (ec *executionContext) marshalNIdentityConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx context.Context, sel ast.SelectionSet, v models.IdentityConnection) graphql.Marshaler {
13660	return ec._IdentityConnection(ctx, sel, &v)
13661}
13662
13663func (ec *executionContext) marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx context.Context, sel ast.SelectionSet, v *models.IdentityConnection) graphql.Marshaler {
13664	if v == nil {
13665		if !ec.HasError(graphql.GetResolverContext(ctx)) {
13666			ec.Errorf(ctx, "must not be null")
13667		}
13668		return graphql.Null
13669	}
13670	return ec._IdentityConnection(ctx, sel, v)
13671}
13672
13673func (ec *executionContext) marshalNIdentityEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx context.Context, sel ast.SelectionSet, v models.IdentityEdge) graphql.Marshaler {
13674	return ec._IdentityEdge(ctx, sel, &v)
13675}
13676
13677func (ec *executionContext) marshalNIdentityEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx context.Context, sel ast.SelectionSet, v []*models.IdentityEdge) graphql.Marshaler {
13678	ret := make(graphql.Array, len(v))
13679	var wg sync.WaitGroup
13680	isLen1 := len(v) == 1
13681	if !isLen1 {
13682		wg.Add(len(v))
13683	}
13684	for i := range v {
13685		i := i
13686		rctx := &graphql.ResolverContext{
13687			Index:  &i,
13688			Result: &v[i],
13689		}
13690		ctx := graphql.WithResolverContext(ctx, rctx)
13691		f := func(i int) {
13692			defer func() {
13693				if r := recover(); r != nil {
13694					ec.Error(ctx, ec.Recover(ctx, r))
13695					ret = nil
13696				}
13697			}()
13698			if !isLen1 {
13699				defer wg.Done()
13700			}
13701			ret[i] = ec.marshalNIdentityEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx, sel, v[i])
13702		}
13703		if isLen1 {
13704			f(i)
13705		} else {
13706			go f(i)
13707		}
13708
13709	}
13710	wg.Wait()
13711	return ret
13712}
13713
13714func (ec *executionContext) marshalNIdentityEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx context.Context, sel ast.SelectionSet, v *models.IdentityEdge) graphql.Marshaler {
13715	if v == nil {
13716		if !ec.HasError(graphql.GetResolverContext(ctx)) {
13717			ec.Errorf(ctx, "must not be null")
13718		}
13719		return graphql.Null
13720	}
13721	return ec._IdentityEdge(ctx, sel, v)
13722}
13723
13724func (ec *executionContext) unmarshalNInt2int(ctx context.Context, v interface{}) (int, error) {
13725	return graphql.UnmarshalInt(v)
13726}
13727
13728func (ec *executionContext) marshalNInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
13729	res := graphql.MarshalInt(v)
13730	if res == graphql.Null {
13731		if !ec.HasError(graphql.GetResolverContext(ctx)) {
13732			ec.Errorf(ctx, "must not be null")
13733		}
13734	}
13735	return res
13736}
13737
13738func (ec *executionContext) marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx context.Context, sel ast.SelectionSet, v bug.Label) graphql.Marshaler {
13739	return ec._Label(ctx, sel, &v)
13740}
13741
13742func (ec *executionContext) marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx context.Context, sel ast.SelectionSet, v []bug.Label) graphql.Marshaler {
13743	ret := make(graphql.Array, len(v))
13744	var wg sync.WaitGroup
13745	isLen1 := len(v) == 1
13746	if !isLen1 {
13747		wg.Add(len(v))
13748	}
13749	for i := range v {
13750		i := i
13751		rctx := &graphql.ResolverContext{
13752			Index:  &i,
13753			Result: &v[i],
13754		}
13755		ctx := graphql.WithResolverContext(ctx, rctx)
13756		f := func(i int) {
13757			defer func() {
13758				if r := recover(); r != nil {
13759					ec.Error(ctx, ec.Recover(ctx, r))
13760					ret = nil
13761				}
13762			}()
13763			if !isLen1 {
13764				defer wg.Done()
13765			}
13766			ret[i] = ec.marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, sel, v[i])
13767		}
13768		if isLen1 {
13769			f(i)
13770		} else {
13771			go f(i)
13772		}
13773
13774	}
13775	wg.Wait()
13776	return ret
13777}
13778
13779func (ec *executionContext) marshalNLabelChangeOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeOperation(ctx context.Context, sel ast.SelectionSet, v bug.LabelChangeOperation) graphql.Marshaler {
13780	return ec._LabelChangeOperation(ctx, sel, &v)
13781}
13782
13783func (ec *executionContext) marshalNLabelChangeOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeOperation(ctx context.Context, sel ast.SelectionSet, v *bug.LabelChangeOperation) graphql.Marshaler {
13784	if v == nil {
13785		if !ec.HasError(graphql.GetResolverContext(ctx)) {
13786			ec.Errorf(ctx, "must not be null")
13787		}
13788		return graphql.Null
13789	}
13790	return ec._LabelChangeOperation(ctx, sel, v)
13791}
13792
13793func (ec *executionContext) marshalNLabelChangeResult2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v []*bug.LabelChangeResult) graphql.Marshaler {
13794	ret := make(graphql.Array, len(v))
13795	var wg sync.WaitGroup
13796	isLen1 := len(v) == 1
13797	if !isLen1 {
13798		wg.Add(len(v))
13799	}
13800	for i := range v {
13801		i := i
13802		rctx := &graphql.ResolverContext{
13803			Index:  &i,
13804			Result: &v[i],
13805		}
13806		ctx := graphql.WithResolverContext(ctx, rctx)
13807		f := func(i int) {
13808			defer func() {
13809				if r := recover(); r != nil {
13810					ec.Error(ctx, ec.Recover(ctx, r))
13811					ret = nil
13812				}
13813			}()
13814			if !isLen1 {
13815				defer wg.Done()
13816			}
13817			ret[i] = ec.marshalOLabelChangeResult2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx, sel, v[i])
13818		}
13819		if isLen1 {
13820			f(i)
13821		} else {
13822			go f(i)
13823		}
13824
13825	}
13826	wg.Wait()
13827	return ret
13828}
13829
13830func (ec *executionContext) unmarshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx context.Context, v interface{}) (models.LabelChangeStatus, error) {
13831	var res models.LabelChangeStatus
13832	return res, res.UnmarshalGQL(v)
13833}
13834
13835func (ec *executionContext) marshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx context.Context, sel ast.SelectionSet, v models.LabelChangeStatus) graphql.Marshaler {
13836	return v
13837}
13838
13839func (ec *executionContext) unmarshalNNewBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugInput(ctx context.Context, v interface{}) (models.NewBugInput, error) {
13840	return ec.unmarshalInputNewBugInput(ctx, v)
13841}
13842
13843func (ec *executionContext) marshalNNewBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugPayload(ctx context.Context, sel ast.SelectionSet, v models.NewBugPayload) graphql.Marshaler {
13844	return ec._NewBugPayload(ctx, sel, &v)
13845}
13846
13847func (ec *executionContext) marshalNNewBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.NewBugPayload) graphql.Marshaler {
13848	if v == nil {
13849		if !ec.HasError(graphql.GetResolverContext(ctx)) {
13850			ec.Errorf(ctx, "must not be null")
13851		}
13852		return graphql.Null
13853	}
13854	return ec._NewBugPayload(ctx, sel, v)
13855}
13856
13857func (ec *executionContext) unmarshalNOpenBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugInput(ctx context.Context, v interface{}) (models.OpenBugInput, error) {
13858	return ec.unmarshalInputOpenBugInput(ctx, v)
13859}
13860
13861func (ec *executionContext) marshalNOpenBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx context.Context, sel ast.SelectionSet, v models.OpenBugPayload) graphql.Marshaler {
13862	return ec._OpenBugPayload(ctx, sel, &v)
13863}
13864
13865func (ec *executionContext) marshalNOpenBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.OpenBugPayload) graphql.Marshaler {
13866	if v == nil {
13867		if !ec.HasError(graphql.GetResolverContext(ctx)) {
13868			ec.Errorf(ctx, "must not be null")
13869		}
13870		return graphql.Null
13871	}
13872	return ec._OpenBugPayload(ctx, sel, v)
13873}
13874
13875func (ec *executionContext) marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx context.Context, sel ast.SelectionSet, v bug.Operation) graphql.Marshaler {
13876	return ec._Operation(ctx, sel, &v)
13877}
13878
13879func (ec *executionContext) marshalNOperation2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx context.Context, sel ast.SelectionSet, v []bug.Operation) graphql.Marshaler {
13880	ret := make(graphql.Array, len(v))
13881	var wg sync.WaitGroup
13882	isLen1 := len(v) == 1
13883	if !isLen1 {
13884		wg.Add(len(v))
13885	}
13886	for i := range v {
13887		i := i
13888		rctx := &graphql.ResolverContext{
13889			Index:  &i,
13890			Result: &v[i],
13891		}
13892		ctx := graphql.WithResolverContext(ctx, rctx)
13893		f := func(i int) {
13894			defer func() {
13895				if r := recover(); r != nil {
13896					ec.Error(ctx, ec.Recover(ctx, r))
13897					ret = nil
13898				}
13899			}()
13900			if !isLen1 {
13901				defer wg.Done()
13902			}
13903			ret[i] = ec.marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx, sel, v[i])
13904		}
13905		if isLen1 {
13906			f(i)
13907		} else {
13908			go f(i)
13909		}
13910
13911	}
13912	wg.Wait()
13913	return ret
13914}
13915
13916func (ec *executionContext) marshalNOperationConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationConnection(ctx context.Context, sel ast.SelectionSet, v models.OperationConnection) graphql.Marshaler {
13917	return ec._OperationConnection(ctx, sel, &v)
13918}
13919
13920func (ec *executionContext) marshalNOperationConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationConnection(ctx context.Context, sel ast.SelectionSet, v *models.OperationConnection) graphql.Marshaler {
13921	if v == nil {
13922		if !ec.HasError(graphql.GetResolverContext(ctx)) {
13923			ec.Errorf(ctx, "must not be null")
13924		}
13925		return graphql.Null
13926	}
13927	return ec._OperationConnection(ctx, sel, v)
13928}
13929
13930func (ec *executionContext) marshalNOperationEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx context.Context, sel ast.SelectionSet, v models.OperationEdge) graphql.Marshaler {
13931	return ec._OperationEdge(ctx, sel, &v)
13932}
13933
13934func (ec *executionContext) marshalNOperationEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx context.Context, sel ast.SelectionSet, v []*models.OperationEdge) graphql.Marshaler {
13935	ret := make(graphql.Array, len(v))
13936	var wg sync.WaitGroup
13937	isLen1 := len(v) == 1
13938	if !isLen1 {
13939		wg.Add(len(v))
13940	}
13941	for i := range v {
13942		i := i
13943		rctx := &graphql.ResolverContext{
13944			Index:  &i,
13945			Result: &v[i],
13946		}
13947		ctx := graphql.WithResolverContext(ctx, rctx)
13948		f := func(i int) {
13949			defer func() {
13950				if r := recover(); r != nil {
13951					ec.Error(ctx, ec.Recover(ctx, r))
13952					ret = nil
13953				}
13954			}()
13955			if !isLen1 {
13956				defer wg.Done()
13957			}
13958			ret[i] = ec.marshalNOperationEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx, sel, v[i])
13959		}
13960		if isLen1 {
13961			f(i)
13962		} else {
13963			go f(i)
13964		}
13965
13966	}
13967	wg.Wait()
13968	return ret
13969}
13970
13971func (ec *executionContext) marshalNOperationEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx context.Context, sel ast.SelectionSet, v *models.OperationEdge) graphql.Marshaler {
13972	if v == nil {
13973		if !ec.HasError(graphql.GetResolverContext(ctx)) {
13974			ec.Errorf(ctx, "must not be null")
13975		}
13976		return graphql.Null
13977	}
13978	return ec._OperationEdge(ctx, sel, v)
13979}
13980
13981func (ec *executionContext) marshalNPageInfo2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx context.Context, sel ast.SelectionSet, v models.PageInfo) graphql.Marshaler {
13982	return ec._PageInfo(ctx, sel, &v)
13983}
13984
13985func (ec *executionContext) marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx context.Context, sel ast.SelectionSet, v *models.PageInfo) graphql.Marshaler {
13986	if v == nil {
13987		if !ec.HasError(graphql.GetResolverContext(ctx)) {
13988			ec.Errorf(ctx, "must not be null")
13989		}
13990		return graphql.Null
13991	}
13992	return ec._PageInfo(ctx, sel, v)
13993}
13994
13995func (ec *executionContext) marshalNSetStatusOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx context.Context, sel ast.SelectionSet, v bug.SetStatusOperation) graphql.Marshaler {
13996	return ec._SetStatusOperation(ctx, sel, &v)
13997}
13998
13999func (ec *executionContext) marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx context.Context, sel ast.SelectionSet, v *bug.SetStatusOperation) graphql.Marshaler {
14000	if v == nil {
14001		if !ec.HasError(graphql.GetResolverContext(ctx)) {
14002			ec.Errorf(ctx, "must not be null")
14003		}
14004		return graphql.Null
14005	}
14006	return ec._SetStatusOperation(ctx, sel, v)
14007}
14008
14009func (ec *executionContext) unmarshalNSetTitleInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitleInput(ctx context.Context, v interface{}) (models.SetTitleInput, error) {
14010	return ec.unmarshalInputSetTitleInput(ctx, v)
14011}
14012
14013func (ec *executionContext) marshalNSetTitleOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetTitleOperation(ctx context.Context, sel ast.SelectionSet, v bug.SetTitleOperation) graphql.Marshaler {
14014	return ec._SetTitleOperation(ctx, sel, &v)
14015}
14016
14017func (ec *executionContext) marshalNSetTitleOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetTitleOperation(ctx context.Context, sel ast.SelectionSet, v *bug.SetTitleOperation) graphql.Marshaler {
14018	if v == nil {
14019		if !ec.HasError(graphql.GetResolverContext(ctx)) {
14020			ec.Errorf(ctx, "must not be null")
14021		}
14022		return graphql.Null
14023	}
14024	return ec._SetTitleOperation(ctx, sel, v)
14025}
14026
14027func (ec *executionContext) marshalNSetTitlePayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx context.Context, sel ast.SelectionSet, v models.SetTitlePayload) graphql.Marshaler {
14028	return ec._SetTitlePayload(ctx, sel, &v)
14029}
14030
14031func (ec *executionContext) marshalNSetTitlePayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx context.Context, sel ast.SelectionSet, v *models.SetTitlePayload) graphql.Marshaler {
14032	if v == nil {
14033		if !ec.HasError(graphql.GetResolverContext(ctx)) {
14034			ec.Errorf(ctx, "must not be null")
14035		}
14036		return graphql.Null
14037	}
14038	return ec._SetTitlePayload(ctx, sel, v)
14039}
14040
14041func (ec *executionContext) unmarshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx context.Context, v interface{}) (models.Status, error) {
14042	var res models.Status
14043	return res, res.UnmarshalGQL(v)
14044}
14045
14046func (ec *executionContext) marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx context.Context, sel ast.SelectionSet, v models.Status) graphql.Marshaler {
14047	return v
14048}
14049
14050func (ec *executionContext) unmarshalNString2string(ctx context.Context, v interface{}) (string, error) {
14051	return graphql.UnmarshalString(v)
14052}
14053
14054func (ec *executionContext) marshalNString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
14055	res := graphql.MarshalString(v)
14056	if res == graphql.Null {
14057		if !ec.HasError(graphql.GetResolverContext(ctx)) {
14058			ec.Errorf(ctx, "must not be null")
14059		}
14060	}
14061	return res
14062}
14063
14064func (ec *executionContext) unmarshalNTime2timeᚐTime(ctx context.Context, v interface{}) (time.Time, error) {
14065	return graphql.UnmarshalTime(v)
14066}
14067
14068func (ec *executionContext) marshalNTime2timeᚐTime(ctx context.Context, sel ast.SelectionSet, v time.Time) graphql.Marshaler {
14069	res := graphql.MarshalTime(v)
14070	if res == graphql.Null {
14071		if !ec.HasError(graphql.GetResolverContext(ctx)) {
14072			ec.Errorf(ctx, "must not be null")
14073		}
14074	}
14075	return res
14076}
14077
14078func (ec *executionContext) unmarshalNTime2ᚖtimeᚐTime(ctx context.Context, v interface{}) (*time.Time, error) {
14079	if v == nil {
14080		return nil, nil
14081	}
14082	res, err := ec.unmarshalNTime2timeᚐTime(ctx, v)
14083	return &res, err
14084}
14085
14086func (ec *executionContext) marshalNTime2ᚖtimeᚐTime(ctx context.Context, sel ast.SelectionSet, v *time.Time) graphql.Marshaler {
14087	if v == nil {
14088		if !ec.HasError(graphql.GetResolverContext(ctx)) {
14089			ec.Errorf(ctx, "must not be null")
14090		}
14091		return graphql.Null
14092	}
14093	return ec.marshalNTime2timeᚐTime(ctx, sel, *v)
14094}
14095
14096func (ec *executionContext) marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx context.Context, sel ast.SelectionSet, v bug.TimelineItem) graphql.Marshaler {
14097	return ec._TimelineItem(ctx, sel, &v)
14098}
14099
14100func (ec *executionContext) marshalNTimelineItem2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx context.Context, sel ast.SelectionSet, v []bug.TimelineItem) graphql.Marshaler {
14101	ret := make(graphql.Array, len(v))
14102	var wg sync.WaitGroup
14103	isLen1 := len(v) == 1
14104	if !isLen1 {
14105		wg.Add(len(v))
14106	}
14107	for i := range v {
14108		i := i
14109		rctx := &graphql.ResolverContext{
14110			Index:  &i,
14111			Result: &v[i],
14112		}
14113		ctx := graphql.WithResolverContext(ctx, rctx)
14114		f := func(i int) {
14115			defer func() {
14116				if r := recover(); r != nil {
14117					ec.Error(ctx, ec.Recover(ctx, r))
14118					ret = nil
14119				}
14120			}()
14121			if !isLen1 {
14122				defer wg.Done()
14123			}
14124			ret[i] = ec.marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx, sel, v[i])
14125		}
14126		if isLen1 {
14127			f(i)
14128		} else {
14129			go f(i)
14130		}
14131
14132	}
14133	wg.Wait()
14134	return ret
14135}
14136
14137func (ec *executionContext) marshalNTimelineItemConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx context.Context, sel ast.SelectionSet, v models.TimelineItemConnection) graphql.Marshaler {
14138	return ec._TimelineItemConnection(ctx, sel, &v)
14139}
14140
14141func (ec *executionContext) marshalNTimelineItemConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx context.Context, sel ast.SelectionSet, v *models.TimelineItemConnection) graphql.Marshaler {
14142	if v == nil {
14143		if !ec.HasError(graphql.GetResolverContext(ctx)) {
14144			ec.Errorf(ctx, "must not be null")
14145		}
14146		return graphql.Null
14147	}
14148	return ec._TimelineItemConnection(ctx, sel, v)
14149}
14150
14151func (ec *executionContext) marshalNTimelineItemEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx context.Context, sel ast.SelectionSet, v models.TimelineItemEdge) graphql.Marshaler {
14152	return ec._TimelineItemEdge(ctx, sel, &v)
14153}
14154
14155func (ec *executionContext) marshalNTimelineItemEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx context.Context, sel ast.SelectionSet, v []*models.TimelineItemEdge) graphql.Marshaler {
14156	ret := make(graphql.Array, len(v))
14157	var wg sync.WaitGroup
14158	isLen1 := len(v) == 1
14159	if !isLen1 {
14160		wg.Add(len(v))
14161	}
14162	for i := range v {
14163		i := i
14164		rctx := &graphql.ResolverContext{
14165			Index:  &i,
14166			Result: &v[i],
14167		}
14168		ctx := graphql.WithResolverContext(ctx, rctx)
14169		f := func(i int) {
14170			defer func() {
14171				if r := recover(); r != nil {
14172					ec.Error(ctx, ec.Recover(ctx, r))
14173					ret = nil
14174				}
14175			}()
14176			if !isLen1 {
14177				defer wg.Done()
14178			}
14179			ret[i] = ec.marshalNTimelineItemEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx, sel, v[i])
14180		}
14181		if isLen1 {
14182			f(i)
14183		} else {
14184			go f(i)
14185		}
14186
14187	}
14188	wg.Wait()
14189	return ret
14190}
14191
14192func (ec *executionContext) marshalNTimelineItemEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx context.Context, sel ast.SelectionSet, v *models.TimelineItemEdge) graphql.Marshaler {
14193	if v == nil {
14194		if !ec.HasError(graphql.GetResolverContext(ctx)) {
14195			ec.Errorf(ctx, "must not be null")
14196		}
14197		return graphql.Null
14198	}
14199	return ec._TimelineItemEdge(ctx, sel, v)
14200}
14201
14202func (ec *executionContext) marshalN__Directive2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx context.Context, sel ast.SelectionSet, v introspection.Directive) graphql.Marshaler {
14203	return ec.___Directive(ctx, sel, &v)
14204}
14205
14206func (ec *executionContext) marshalN__Directive2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx context.Context, sel ast.SelectionSet, v []introspection.Directive) graphql.Marshaler {
14207	ret := make(graphql.Array, len(v))
14208	var wg sync.WaitGroup
14209	isLen1 := len(v) == 1
14210	if !isLen1 {
14211		wg.Add(len(v))
14212	}
14213	for i := range v {
14214		i := i
14215		rctx := &graphql.ResolverContext{
14216			Index:  &i,
14217			Result: &v[i],
14218		}
14219		ctx := graphql.WithResolverContext(ctx, rctx)
14220		f := func(i int) {
14221			defer func() {
14222				if r := recover(); r != nil {
14223					ec.Error(ctx, ec.Recover(ctx, r))
14224					ret = nil
14225				}
14226			}()
14227			if !isLen1 {
14228				defer wg.Done()
14229			}
14230			ret[i] = ec.marshalN__Directive2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx, sel, v[i])
14231		}
14232		if isLen1 {
14233			f(i)
14234		} else {
14235			go f(i)
14236		}
14237
14238	}
14239	wg.Wait()
14240	return ret
14241}
14242
14243func (ec *executionContext) unmarshalN__DirectiveLocation2string(ctx context.Context, v interface{}) (string, error) {
14244	return graphql.UnmarshalString(v)
14245}
14246
14247func (ec *executionContext) marshalN__DirectiveLocation2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
14248	res := graphql.MarshalString(v)
14249	if res == graphql.Null {
14250		if !ec.HasError(graphql.GetResolverContext(ctx)) {
14251			ec.Errorf(ctx, "must not be null")
14252		}
14253	}
14254	return res
14255}
14256
14257func (ec *executionContext) unmarshalN__DirectiveLocation2ᚕstring(ctx context.Context, v interface{}) ([]string, error) {
14258	var vSlice []interface{}
14259	if v != nil {
14260		if tmp1, ok := v.([]interface{}); ok {
14261			vSlice = tmp1
14262		} else {
14263			vSlice = []interface{}{v}
14264		}
14265	}
14266	var err error
14267	res := make([]string, len(vSlice))
14268	for i := range vSlice {
14269		res[i], err = ec.unmarshalN__DirectiveLocation2string(ctx, vSlice[i])
14270		if err != nil {
14271			return nil, err
14272		}
14273	}
14274	return res, nil
14275}
14276
14277func (ec *executionContext) marshalN__DirectiveLocation2ᚕstring(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
14278	ret := make(graphql.Array, len(v))
14279	var wg sync.WaitGroup
14280	isLen1 := len(v) == 1
14281	if !isLen1 {
14282		wg.Add(len(v))
14283	}
14284	for i := range v {
14285		i := i
14286		rctx := &graphql.ResolverContext{
14287			Index:  &i,
14288			Result: &v[i],
14289		}
14290		ctx := graphql.WithResolverContext(ctx, rctx)
14291		f := func(i int) {
14292			defer func() {
14293				if r := recover(); r != nil {
14294					ec.Error(ctx, ec.Recover(ctx, r))
14295					ret = nil
14296				}
14297			}()
14298			if !isLen1 {
14299				defer wg.Done()
14300			}
14301			ret[i] = ec.marshalN__DirectiveLocation2string(ctx, sel, v[i])
14302		}
14303		if isLen1 {
14304			f(i)
14305		} else {
14306			go f(i)
14307		}
14308
14309	}
14310	wg.Wait()
14311	return ret
14312}
14313
14314func (ec *executionContext) marshalN__EnumValue2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx context.Context, sel ast.SelectionSet, v introspection.EnumValue) graphql.Marshaler {
14315	return ec.___EnumValue(ctx, sel, &v)
14316}
14317
14318func (ec *executionContext) marshalN__Field2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx context.Context, sel ast.SelectionSet, v introspection.Field) graphql.Marshaler {
14319	return ec.___Field(ctx, sel, &v)
14320}
14321
14322func (ec *executionContext) marshalN__InputValue2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx context.Context, sel ast.SelectionSet, v introspection.InputValue) graphql.Marshaler {
14323	return ec.___InputValue(ctx, sel, &v)
14324}
14325
14326func (ec *executionContext) marshalN__InputValue2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
14327	ret := make(graphql.Array, len(v))
14328	var wg sync.WaitGroup
14329	isLen1 := len(v) == 1
14330	if !isLen1 {
14331		wg.Add(len(v))
14332	}
14333	for i := range v {
14334		i := i
14335		rctx := &graphql.ResolverContext{
14336			Index:  &i,
14337			Result: &v[i],
14338		}
14339		ctx := graphql.WithResolverContext(ctx, rctx)
14340		f := func(i int) {
14341			defer func() {
14342				if r := recover(); r != nil {
14343					ec.Error(ctx, ec.Recover(ctx, r))
14344					ret = nil
14345				}
14346			}()
14347			if !isLen1 {
14348				defer wg.Done()
14349			}
14350			ret[i] = ec.marshalN__InputValue2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
14351		}
14352		if isLen1 {
14353			f(i)
14354		} else {
14355			go f(i)
14356		}
14357
14358	}
14359	wg.Wait()
14360	return ret
14361}
14362
14363func (ec *executionContext) marshalN__Type2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v introspection.Type) graphql.Marshaler {
14364	return ec.___Type(ctx, sel, &v)
14365}
14366
14367func (ec *executionContext) marshalN__Type2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
14368	ret := make(graphql.Array, len(v))
14369	var wg sync.WaitGroup
14370	isLen1 := len(v) == 1
14371	if !isLen1 {
14372		wg.Add(len(v))
14373	}
14374	for i := range v {
14375		i := i
14376		rctx := &graphql.ResolverContext{
14377			Index:  &i,
14378			Result: &v[i],
14379		}
14380		ctx := graphql.WithResolverContext(ctx, rctx)
14381		f := func(i int) {
14382			defer func() {
14383				if r := recover(); r != nil {
14384					ec.Error(ctx, ec.Recover(ctx, r))
14385					ret = nil
14386				}
14387			}()
14388			if !isLen1 {
14389				defer wg.Done()
14390			}
14391			ret[i] = ec.marshalN__Type2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
14392		}
14393		if isLen1 {
14394			f(i)
14395		} else {
14396			go f(i)
14397		}
14398
14399	}
14400	wg.Wait()
14401	return ret
14402}
14403
14404func (ec *executionContext) marshalN__Type2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
14405	if v == nil {
14406		if !ec.HasError(graphql.GetResolverContext(ctx)) {
14407			ec.Errorf(ctx, "must not be null")
14408		}
14409		return graphql.Null
14410	}
14411	return ec.___Type(ctx, sel, v)
14412}
14413
14414func (ec *executionContext) unmarshalN__TypeKind2string(ctx context.Context, v interface{}) (string, error) {
14415	return graphql.UnmarshalString(v)
14416}
14417
14418func (ec *executionContext) marshalN__TypeKind2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
14419	res := graphql.MarshalString(v)
14420	if res == graphql.Null {
14421		if !ec.HasError(graphql.GetResolverContext(ctx)) {
14422			ec.Errorf(ctx, "must not be null")
14423		}
14424	}
14425	return res
14426}
14427
14428func (ec *executionContext) unmarshalOBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
14429	return graphql.UnmarshalBoolean(v)
14430}
14431
14432func (ec *executionContext) marshalOBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
14433	return graphql.MarshalBoolean(v)
14434}
14435
14436func (ec *executionContext) unmarshalOBoolean2ᚖbool(ctx context.Context, v interface{}) (*bool, error) {
14437	if v == nil {
14438		return nil, nil
14439	}
14440	res, err := ec.unmarshalOBoolean2bool(ctx, v)
14441	return &res, err
14442}
14443
14444func (ec *executionContext) marshalOBoolean2ᚖbool(ctx context.Context, sel ast.SelectionSet, v *bool) graphql.Marshaler {
14445	if v == nil {
14446		return graphql.Null
14447	}
14448	return ec.marshalOBoolean2bool(ctx, sel, *v)
14449}
14450
14451func (ec *executionContext) marshalOBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx context.Context, sel ast.SelectionSet, v bug.Snapshot) graphql.Marshaler {
14452	return ec._Bug(ctx, sel, &v)
14453}
14454
14455func (ec *executionContext) marshalOBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx context.Context, sel ast.SelectionSet, v *bug.Snapshot) graphql.Marshaler {
14456	if v == nil {
14457		return graphql.Null
14458	}
14459	return ec._Bug(ctx, sel, v)
14460}
14461
14462func (ec *executionContext) unmarshalOChangeLabelInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx context.Context, v interface{}) (models.ChangeLabelInput, error) {
14463	return ec.unmarshalInputChangeLabelInput(ctx, v)
14464}
14465
14466func (ec *executionContext) unmarshalOChangeLabelInput2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx context.Context, v interface{}) (*models.ChangeLabelInput, error) {
14467	if v == nil {
14468		return nil, nil
14469	}
14470	res, err := ec.unmarshalOChangeLabelInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx, v)
14471	return &res, err
14472}
14473
14474func (ec *executionContext) unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx context.Context, v interface{}) ([]git.Hash, error) {
14475	var vSlice []interface{}
14476	if v != nil {
14477		if tmp1, ok := v.([]interface{}); ok {
14478			vSlice = tmp1
14479		} else {
14480			vSlice = []interface{}{v}
14481		}
14482	}
14483	var err error
14484	res := make([]git.Hash, len(vSlice))
14485	for i := range vSlice {
14486		res[i], err = ec.unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, vSlice[i])
14487		if err != nil {
14488			return nil, err
14489		}
14490	}
14491	return res, nil
14492}
14493
14494func (ec *executionContext) marshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx context.Context, sel ast.SelectionSet, v []git.Hash) graphql.Marshaler {
14495	if v == nil {
14496		return graphql.Null
14497	}
14498	ret := make(graphql.Array, len(v))
14499	for i := range v {
14500		ret[i] = ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, sel, v[i])
14501	}
14502
14503	return ret
14504}
14505
14506func (ec *executionContext) marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx context.Context, sel ast.SelectionSet, v identity.Interface) graphql.Marshaler {
14507	return ec._Identity(ctx, sel, &v)
14508}
14509
14510func (ec *executionContext) unmarshalOInt2int(ctx context.Context, v interface{}) (int, error) {
14511	return graphql.UnmarshalInt(v)
14512}
14513
14514func (ec *executionContext) marshalOInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
14515	return graphql.MarshalInt(v)
14516}
14517
14518func (ec *executionContext) unmarshalOInt2ᚖint(ctx context.Context, v interface{}) (*int, error) {
14519	if v == nil {
14520		return nil, nil
14521	}
14522	res, err := ec.unmarshalOInt2int(ctx, v)
14523	return &res, err
14524}
14525
14526func (ec *executionContext) marshalOInt2ᚖint(ctx context.Context, sel ast.SelectionSet, v *int) graphql.Marshaler {
14527	if v == nil {
14528		return graphql.Null
14529	}
14530	return ec.marshalOInt2int(ctx, sel, *v)
14531}
14532
14533func (ec *executionContext) marshalOLabelChangeResult2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v bug.LabelChangeResult) graphql.Marshaler {
14534	return ec._LabelChangeResult(ctx, sel, &v)
14535}
14536
14537func (ec *executionContext) marshalOLabelChangeResult2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v *bug.LabelChangeResult) graphql.Marshaler {
14538	if v == nil {
14539		return graphql.Null
14540	}
14541	return ec._LabelChangeResult(ctx, sel, v)
14542}
14543
14544func (ec *executionContext) marshalORepository2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRepository(ctx context.Context, sel ast.SelectionSet, v models.Repository) graphql.Marshaler {
14545	return ec._Repository(ctx, sel, &v)
14546}
14547
14548func (ec *executionContext) marshalORepository2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRepository(ctx context.Context, sel ast.SelectionSet, v *models.Repository) graphql.Marshaler {
14549	if v == nil {
14550		return graphql.Null
14551	}
14552	return ec._Repository(ctx, sel, v)
14553}
14554
14555func (ec *executionContext) unmarshalOString2string(ctx context.Context, v interface{}) (string, error) {
14556	return graphql.UnmarshalString(v)
14557}
14558
14559func (ec *executionContext) marshalOString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
14560	return graphql.MarshalString(v)
14561}
14562
14563func (ec *executionContext) unmarshalOString2ᚕstring(ctx context.Context, v interface{}) ([]string, error) {
14564	var vSlice []interface{}
14565	if v != nil {
14566		if tmp1, ok := v.([]interface{}); ok {
14567			vSlice = tmp1
14568		} else {
14569			vSlice = []interface{}{v}
14570		}
14571	}
14572	var err error
14573	res := make([]string, len(vSlice))
14574	for i := range vSlice {
14575		res[i], err = ec.unmarshalNString2string(ctx, vSlice[i])
14576		if err != nil {
14577			return nil, err
14578		}
14579	}
14580	return res, nil
14581}
14582
14583func (ec *executionContext) marshalOString2ᚕstring(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
14584	if v == nil {
14585		return graphql.Null
14586	}
14587	ret := make(graphql.Array, len(v))
14588	for i := range v {
14589		ret[i] = ec.marshalNString2string(ctx, sel, v[i])
14590	}
14591
14592	return ret
14593}
14594
14595func (ec *executionContext) unmarshalOString2ᚖstring(ctx context.Context, v interface{}) (*string, error) {
14596	if v == nil {
14597		return nil, nil
14598	}
14599	res, err := ec.unmarshalOString2string(ctx, v)
14600	return &res, err
14601}
14602
14603func (ec *executionContext) marshalOString2ᚖstring(ctx context.Context, sel ast.SelectionSet, v *string) graphql.Marshaler {
14604	if v == nil {
14605		return graphql.Null
14606	}
14607	return ec.marshalOString2string(ctx, sel, *v)
14608}
14609
14610func (ec *executionContext) marshalO__EnumValue2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx context.Context, sel ast.SelectionSet, v []introspection.EnumValue) graphql.Marshaler {
14611	if v == nil {
14612		return graphql.Null
14613	}
14614	ret := make(graphql.Array, len(v))
14615	var wg sync.WaitGroup
14616	isLen1 := len(v) == 1
14617	if !isLen1 {
14618		wg.Add(len(v))
14619	}
14620	for i := range v {
14621		i := i
14622		rctx := &graphql.ResolverContext{
14623			Index:  &i,
14624			Result: &v[i],
14625		}
14626		ctx := graphql.WithResolverContext(ctx, rctx)
14627		f := func(i int) {
14628			defer func() {
14629				if r := recover(); r != nil {
14630					ec.Error(ctx, ec.Recover(ctx, r))
14631					ret = nil
14632				}
14633			}()
14634			if !isLen1 {
14635				defer wg.Done()
14636			}
14637			ret[i] = ec.marshalN__EnumValue2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx, sel, v[i])
14638		}
14639		if isLen1 {
14640			f(i)
14641		} else {
14642			go f(i)
14643		}
14644
14645	}
14646	wg.Wait()
14647	return ret
14648}
14649
14650func (ec *executionContext) marshalO__Field2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx context.Context, sel ast.SelectionSet, v []introspection.Field) graphql.Marshaler {
14651	if v == nil {
14652		return graphql.Null
14653	}
14654	ret := make(graphql.Array, len(v))
14655	var wg sync.WaitGroup
14656	isLen1 := len(v) == 1
14657	if !isLen1 {
14658		wg.Add(len(v))
14659	}
14660	for i := range v {
14661		i := i
14662		rctx := &graphql.ResolverContext{
14663			Index:  &i,
14664			Result: &v[i],
14665		}
14666		ctx := graphql.WithResolverContext(ctx, rctx)
14667		f := func(i int) {
14668			defer func() {
14669				if r := recover(); r != nil {
14670					ec.Error(ctx, ec.Recover(ctx, r))
14671					ret = nil
14672				}
14673			}()
14674			if !isLen1 {
14675				defer wg.Done()
14676			}
14677			ret[i] = ec.marshalN__Field2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx, sel, v[i])
14678		}
14679		if isLen1 {
14680			f(i)
14681		} else {
14682			go f(i)
14683		}
14684
14685	}
14686	wg.Wait()
14687	return ret
14688}
14689
14690func (ec *executionContext) marshalO__InputValue2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
14691	if v == nil {
14692		return graphql.Null
14693	}
14694	ret := make(graphql.Array, len(v))
14695	var wg sync.WaitGroup
14696	isLen1 := len(v) == 1
14697	if !isLen1 {
14698		wg.Add(len(v))
14699	}
14700	for i := range v {
14701		i := i
14702		rctx := &graphql.ResolverContext{
14703			Index:  &i,
14704			Result: &v[i],
14705		}
14706		ctx := graphql.WithResolverContext(ctx, rctx)
14707		f := func(i int) {
14708			defer func() {
14709				if r := recover(); r != nil {
14710					ec.Error(ctx, ec.Recover(ctx, r))
14711					ret = nil
14712				}
14713			}()
14714			if !isLen1 {
14715				defer wg.Done()
14716			}
14717			ret[i] = ec.marshalN__InputValue2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
14718		}
14719		if isLen1 {
14720			f(i)
14721		} else {
14722			go f(i)
14723		}
14724
14725	}
14726	wg.Wait()
14727	return ret
14728}
14729
14730func (ec *executionContext) marshalO__Schema2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx context.Context, sel ast.SelectionSet, v introspection.Schema) graphql.Marshaler {
14731	return ec.___Schema(ctx, sel, &v)
14732}
14733
14734func (ec *executionContext) marshalO__Schema2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx context.Context, sel ast.SelectionSet, v *introspection.Schema) graphql.Marshaler {
14735	if v == nil {
14736		return graphql.Null
14737	}
14738	return ec.___Schema(ctx, sel, v)
14739}
14740
14741func (ec *executionContext) marshalO__Type2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v introspection.Type) graphql.Marshaler {
14742	return ec.___Type(ctx, sel, &v)
14743}
14744
14745func (ec *executionContext) marshalO__Type2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
14746	if v == nil {
14747		return graphql.Null
14748	}
14749	ret := make(graphql.Array, len(v))
14750	var wg sync.WaitGroup
14751	isLen1 := len(v) == 1
14752	if !isLen1 {
14753		wg.Add(len(v))
14754	}
14755	for i := range v {
14756		i := i
14757		rctx := &graphql.ResolverContext{
14758			Index:  &i,
14759			Result: &v[i],
14760		}
14761		ctx := graphql.WithResolverContext(ctx, rctx)
14762		f := func(i int) {
14763			defer func() {
14764				if r := recover(); r != nil {
14765					ec.Error(ctx, ec.Recover(ctx, r))
14766					ret = nil
14767				}
14768			}()
14769			if !isLen1 {
14770				defer wg.Done()
14771			}
14772			ret[i] = ec.marshalN__Type2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
14773		}
14774		if isLen1 {
14775			f(i)
14776		} else {
14777			go f(i)
14778		}
14779
14780	}
14781	wg.Wait()
14782	return ret
14783}
14784
14785func (ec *executionContext) marshalO__Type2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
14786	if v == nil {
14787		return graphql.Null
14788	}
14789	return ec.___Type(ctx, sel, v)
14790}
14791
14792// endregion ***************************** type.gotpl *****************************