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) FieldMiddleware(ctx context.Context, obj interface{}, next graphql.Resolver) (ret interface{}) {
 1791	defer func() {
 1792		if r := recover(); r != nil {
 1793			ec.Error(ctx, ec.Recover(ctx, r))
 1794			ret = nil
 1795		}
 1796	}()
 1797	res, err := ec.ResolverMiddleware(ctx, next)
 1798	if err != nil {
 1799		ec.Error(ctx, err)
 1800		return nil
 1801	}
 1802	return res
 1803}
 1804
 1805func (ec *executionContext) introspectSchema() (*introspection.Schema, error) {
 1806	if ec.DisableIntrospection {
 1807		return nil, errors.New("introspection disabled")
 1808	}
 1809	return introspection.WrapSchema(parsedSchema), nil
 1810}
 1811
 1812func (ec *executionContext) introspectType(name string) (*introspection.Type, error) {
 1813	if ec.DisableIntrospection {
 1814		return nil, errors.New("introspection disabled")
 1815	}
 1816	return introspection.WrapTypeFromDef(parsedSchema, parsedSchema.Types[name]), nil
 1817}
 1818
 1819var parsedSchema = gqlparser.MustLoadSchema(
 1820	&ast.Source{Name: "schema/bug.graphql", Input: `"""Represents a comment on a bug."""
 1821type Comment implements Authored {
 1822  """The author of this comment."""
 1823  author: Identity!
 1824
 1825  """The message of this comment."""
 1826  message: String!
 1827
 1828  """All media's hash referenced in this comment"""
 1829  files: [Hash!]!
 1830}
 1831
 1832type CommentConnection {
 1833  edges: [CommentEdge!]!
 1834  nodes: [Comment!]!
 1835  pageInfo: PageInfo!
 1836  totalCount: Int!
 1837}
 1838
 1839type CommentEdge {
 1840  cursor: String!
 1841  node: Comment!
 1842}
 1843
 1844enum Status {
 1845  OPEN
 1846  CLOSED
 1847}
 1848
 1849type Bug implements Authored {
 1850  """The identifier for this bug"""
 1851  id: String!
 1852  """The human version (truncated) identifier for this bug"""
 1853  humanId: String!
 1854  status: Status!
 1855  title: String!
 1856  labels: [Label!]!
 1857  author: Identity!
 1858  createdAt: Time!
 1859  lastEdit: Time!
 1860
 1861  """The actors of the bug. Actors are Identity that have interacted with the bug."""
 1862  actors(
 1863    """Returns the elements in the list that come after the specified cursor."""
 1864    after: String
 1865    """Returns the elements in the list that come before the specified cursor."""
 1866    before: String
 1867    """Returns the first _n_ elements from the list."""
 1868    first: Int
 1869    """Returns the last _n_ elements from the list."""
 1870    last: Int
 1871  ): IdentityConnection!
 1872
 1873  """The participants of the bug. Participants are Identity that have created or
 1874  added a comment on the bug."""
 1875  participants(
 1876    """Returns the elements in the list that come after the specified cursor."""
 1877    after: String
 1878    """Returns the elements in the list that come before the specified cursor."""
 1879    before: String
 1880    """Returns the first _n_ elements from the list."""
 1881    first: Int
 1882    """Returns the last _n_ elements from the list."""
 1883    last: Int
 1884  ): IdentityConnection!
 1885
 1886  comments(
 1887    """Returns the elements in the list that come after the specified cursor."""
 1888    after: String
 1889    """Returns the elements in the list that come before the specified cursor."""
 1890    before: String
 1891    """Returns the first _n_ elements from the list."""
 1892    first: Int
 1893    """Returns the last _n_ elements from the list."""
 1894    last: Int
 1895  ): CommentConnection!
 1896
 1897  timeline(
 1898    """Returns the elements in the list that come after the specified cursor."""
 1899    after: String
 1900    """Returns the elements in the list that come before the specified cursor."""
 1901    before: String
 1902    """Returns the first _n_ elements from the list."""
 1903    first: Int
 1904    """Returns the last _n_ elements from the list."""
 1905    last: Int
 1906  ): TimelineItemConnection!
 1907
 1908  operations(
 1909    """Returns the elements in the list that come after the specified cursor."""
 1910    after: String
 1911    """Returns the elements in the list that come before the specified cursor."""
 1912    before: String
 1913    """Returns the first _n_ elements from the list."""
 1914    first: Int
 1915    """Returns the last _n_ elements from the list."""
 1916    last: Int
 1917  ): OperationConnection!
 1918}
 1919
 1920"""The connection type for Bug."""
 1921type BugConnection {
 1922  """A list of edges."""
 1923  edges: [BugEdge!]!
 1924  nodes: [Bug!]!
 1925  """Information to aid in pagination."""
 1926  pageInfo: PageInfo!
 1927  """Identifies the total count of items in the connection."""
 1928  totalCount: Int!
 1929}
 1930
 1931"""An edge in a connection."""
 1932type BugEdge {
 1933  """A cursor for use in pagination."""
 1934  cursor: String!
 1935  """The item at the end of the edge."""
 1936  node: Bug!
 1937}
 1938`},
 1939	&ast.Source{Name: "schema/identity.graphql", Input: `"""Represents an identity"""
 1940type Identity {
 1941    """The identifier for this identity"""
 1942    id: String!
 1943    """The human version (truncated) identifier for this identity"""
 1944    humanId: String!
 1945    """The name of the person, if known."""
 1946    name: String
 1947    """The email of the person, if known."""
 1948    email: String
 1949    """The login of the person, if known."""
 1950    login: String
 1951    """A string containing the either the name of the person, its login or both"""
 1952    displayName: String!
 1953    """An url to an avatar"""
 1954    avatarUrl: String
 1955    """isProtected is true if the chain of git commits started to be signed.
 1956    If that's the case, only signed commit with a valid key for this identity can be added."""
 1957    isProtected: Boolean!
 1958}
 1959
 1960type IdentityConnection {
 1961    edges: [IdentityEdge!]!
 1962    nodes: [Identity!]!
 1963    pageInfo: PageInfo!
 1964    totalCount: Int!
 1965}
 1966
 1967type IdentityEdge {
 1968    cursor: String!
 1969    node: Identity!
 1970}`},
 1971	&ast.Source{Name: "schema/mutations.graphql", Input: `input NewBugInput {
 1972    """A unique identifier for the client performing the mutation."""
 1973    clientMutationId: String
 1974    """"The name of the repository. If not set, the default repository is used."""
 1975    repoRef: String
 1976    """The title of the new bug."""
 1977    title: String!
 1978    """The first message of the new bug."""
 1979    message: String!
 1980    """The collection of file's hash required for the first message."""
 1981    files: [Hash!]
 1982}
 1983
 1984type NewBugPayload {
 1985    """A unique identifier for the client performing the mutation."""
 1986    clientMutationId: String
 1987    """The created bug."""
 1988    bug: Bug!
 1989    """The resulting operation."""
 1990    operation: CreateOperation!
 1991}
 1992
 1993input AddCommentInput {
 1994    """A unique identifier for the client performing the mutation."""
 1995    clientMutationId: String
 1996    """"The name of the repository. If not set, the default repository is used."""
 1997    repoRef: String
 1998    """The bug ID's prefix."""
 1999    prefix: String!
 2000    """The first message of the new bug."""
 2001    message: String!
 2002    """The collection of file's hash required for the first message."""
 2003    files: [Hash!]
 2004}
 2005
 2006type AddCommentPayload {
 2007    """A unique identifier for the client performing the mutation."""
 2008    clientMutationId: String
 2009    """The affected bug."""
 2010    bug: Bug!
 2011    """The resulting operation."""
 2012    operation: AddCommentOperation!
 2013}
 2014
 2015input ChangeLabelInput {
 2016    """A unique identifier for the client performing the mutation."""
 2017    clientMutationId: String
 2018    """"The name of the repository. If not set, the default repository is used."""
 2019    repoRef: String
 2020    """The bug ID's prefix."""
 2021    prefix: String!
 2022    """The list of label to add."""
 2023    added: [String!]
 2024    """The list of label to remove."""
 2025    Removed: [String!]
 2026}
 2027
 2028enum LabelChangeStatus {
 2029    ADDED
 2030    REMOVED
 2031    DUPLICATE_IN_OP
 2032    ALREADY_EXIST
 2033    DOESNT_EXIST
 2034}
 2035
 2036type LabelChangeResult {
 2037    """The source label."""
 2038    label: Label!
 2039    """The effect this label had."""
 2040    status: LabelChangeStatus!
 2041}
 2042
 2043type ChangeLabelPayload {
 2044    """A unique identifier for the client performing the mutation."""
 2045    clientMutationId: String
 2046    """The affected bug."""
 2047    bug: Bug!
 2048    """The resulting operation."""
 2049    operation: LabelChangeOperation!
 2050    """The effect each source label had."""
 2051    results: [LabelChangeResult]!
 2052}
 2053
 2054input OpenBugInput {
 2055    """A unique identifier for the client performing the mutation."""
 2056    clientMutationId: String
 2057    """"The name of the repository. If not set, the default repository is used."""
 2058    repoRef: String
 2059    """The bug ID's prefix."""
 2060    prefix: String!
 2061}
 2062
 2063type OpenBugPayload {
 2064    """A unique identifier for the client performing the mutation."""
 2065    clientMutationId: String
 2066    """The affected bug."""
 2067    bug: Bug!
 2068    """The resulting operation."""
 2069    operation: SetStatusOperation!
 2070}
 2071
 2072input CloseBugInput {
 2073    """A unique identifier for the client performing the mutation."""
 2074    clientMutationId: String
 2075    """"The name of the repository. If not set, the default repository is used."""
 2076    repoRef: String
 2077    """The bug ID's prefix."""
 2078    prefix: String!
 2079}
 2080
 2081type CloseBugPayload {
 2082    """A unique identifier for the client performing the mutation."""
 2083    clientMutationId: String
 2084    """The affected bug."""
 2085    bug: Bug!
 2086    """The resulting operation."""
 2087    operation: SetStatusOperation!
 2088}
 2089
 2090input SetTitleInput {
 2091    """A unique identifier for the client performing the mutation."""
 2092    clientMutationId: String
 2093    """"The name of the repository. If not set, the default repository is used."""
 2094    repoRef: String
 2095    """The bug ID's prefix."""
 2096    prefix: String!
 2097    """The new title."""
 2098    title: String!
 2099}
 2100
 2101type SetTitlePayload {
 2102    """A unique identifier for the client performing the mutation."""
 2103    clientMutationId: String
 2104    """The affected bug."""
 2105    bug: Bug!
 2106    """The resulting operation"""
 2107    operation: SetTitleOperation!
 2108}
 2109
 2110input CommitInput {
 2111    """A unique identifier for the client performing the mutation."""
 2112    clientMutationId: String
 2113    """"The name of the repository. If not set, the default repository is used."""
 2114    repoRef: String
 2115    """The bug ID's prefix."""
 2116    prefix: String!
 2117}
 2118
 2119type CommitPayload {
 2120    """A unique identifier for the client performing the mutation."""
 2121    clientMutationId: String
 2122    """The affected bug."""
 2123    bug: Bug!
 2124}
 2125
 2126input CommitAsNeededInput {
 2127    """A unique identifier for the client performing the mutation."""
 2128    clientMutationId: String
 2129    """"The name of the repository. If not set, the default repository is used."""
 2130    repoRef: String
 2131    """The bug ID's prefix."""
 2132    prefix: String!
 2133}
 2134
 2135type CommitAsNeededPayload {
 2136    """A unique identifier for the client performing the mutation."""
 2137    clientMutationId: String
 2138    """The affected bug."""
 2139    bug: Bug!
 2140}
 2141`},
 2142	&ast.Source{Name: "schema/operations.graphql", Input: `"""An operation applied to a bug."""
 2143interface Operation {
 2144    """The hash of the operation"""
 2145    hash: Hash!
 2146    """The operations author."""
 2147    author: Identity!
 2148    """The datetime when this operation was issued."""
 2149    date: Time!
 2150}
 2151
 2152# Connection
 2153
 2154"""The connection type for an Operation"""
 2155type OperationConnection {
 2156    edges: [OperationEdge!]!
 2157    nodes: [Operation!]!
 2158    pageInfo: PageInfo!
 2159    totalCount: Int!
 2160}
 2161
 2162"""Represent an Operation"""
 2163type OperationEdge {
 2164    cursor: String!
 2165    node: Operation!
 2166}
 2167
 2168# Operations
 2169
 2170type CreateOperation implements Operation & Authored {
 2171    """The hash of the operation"""
 2172    hash: Hash!
 2173    """The author of this object."""
 2174    author: Identity!
 2175    """The datetime when this operation was issued."""
 2176    date: Time!
 2177
 2178    title: String!
 2179    message: String!
 2180    files: [Hash!]!
 2181}
 2182
 2183type SetTitleOperation implements Operation & Authored {
 2184    """The hash of the operation"""
 2185    hash: Hash!
 2186    """The author of this object."""
 2187    author: Identity!
 2188    """The datetime when this operation was issued."""
 2189    date: Time!
 2190
 2191    title: String!
 2192    was: String!
 2193}
 2194
 2195type AddCommentOperation implements Operation & Authored {
 2196    """The hash of the operation"""
 2197    hash: Hash!
 2198    """The author of this object."""
 2199    author: Identity!
 2200    """The datetime when this operation was issued."""
 2201    date: Time!
 2202
 2203    message: String!
 2204    files: [Hash!]!
 2205}
 2206
 2207type EditCommentOperation implements Operation & Authored {
 2208    """The hash of the operation"""
 2209    hash: Hash!
 2210    """The author of this object."""
 2211    author: Identity!
 2212    """The datetime when this operation was issued."""
 2213    date: Time!
 2214
 2215    target: Hash!
 2216    message: String!
 2217    files: [Hash!]!
 2218}
 2219
 2220type SetStatusOperation implements Operation & Authored {
 2221    """The hash of the operation"""
 2222    hash: Hash!
 2223    """The author of this object."""
 2224    author: Identity!
 2225    """The datetime when this operation was issued."""
 2226    date: Time!
 2227
 2228    status: Status!
 2229}
 2230
 2231type LabelChangeOperation implements Operation & Authored {
 2232    """The hash of the operation"""
 2233    hash: Hash!
 2234    """The author of this object."""
 2235    author: Identity!
 2236    """The datetime when this operation was issued."""
 2237    date: Time!
 2238
 2239    added: [Label!]!
 2240    removed: [Label!]!
 2241}
 2242`},
 2243	&ast.Source{Name: "schema/repository.graphql", Input: `
 2244type Repository {
 2245    """All the bugs"""
 2246    allBugs(
 2247        """Returns the elements in the list that come after the specified cursor."""
 2248        after: String
 2249        """Returns the elements in the list that come before the specified cursor."""
 2250        before: String
 2251        """Returns the first _n_ elements from the list."""
 2252        first: Int
 2253        """Returns the last _n_ elements from the list."""
 2254        last: Int
 2255        """A query to select and order bugs"""
 2256        query: String
 2257    ): BugConnection!
 2258
 2259    bug(prefix: String!): Bug
 2260
 2261    """All the identities"""
 2262    allIdentities(
 2263        """Returns the elements in the list that come after the specified cursor."""
 2264        after: String
 2265        """Returns the elements in the list that come before the specified cursor."""
 2266        before: String
 2267        """Returns the first _n_ elements from the list."""
 2268        first: Int
 2269        """Returns the last _n_ elements from the list."""
 2270        last: Int
 2271    ): IdentityConnection!
 2272
 2273    identity(prefix: String!): Identity
 2274
 2275    """The identity created or selected by the user as its own"""
 2276    userIdentity: Identity
 2277
 2278    """List of valid labels."""
 2279    validLabels: [Label!]!
 2280}`},
 2281	&ast.Source{Name: "schema/root.graphql", Input: `type Query {
 2282    """The default unnamend repository."""
 2283    defaultRepository: Repository
 2284    """Access a repository by reference/name."""
 2285    repository(ref: String!): Repository
 2286}
 2287
 2288type Mutation {
 2289    """Create a new bug"""
 2290    newBug(input: NewBugInput!): NewBugPayload!
 2291    """Add a new comment to a bug"""
 2292    addComment(input: AddCommentInput!): AddCommentPayload!
 2293    """Add or remove a set of label on a bug"""
 2294    changeLabels(input: ChangeLabelInput): ChangeLabelPayload!
 2295    """Change a bug's status to open"""
 2296    openBug(input: OpenBugInput!): OpenBugPayload!
 2297    """Change a bug's status to closed"""
 2298    closeBug(input: CloseBugInput!): CloseBugPayload!
 2299    """Change a bug's titlel"""
 2300    setTitle(input: SetTitleInput!): SetTitlePayload!
 2301    """Commit write the pending operations into storage. This mutation fail if nothing is pending"""
 2302    commit(input: CommitInput!): CommitPayload!
 2303    """Commit write the pending operations into storage. This mutation succed if nothing is pending"""
 2304    commitAsNeeded(input: CommitAsNeededInput!): CommitAsNeededPayload!
 2305}
 2306`},
 2307	&ast.Source{Name: "schema/timeline.graphql", Input: `"""An item in the timeline of events"""
 2308interface TimelineItem {
 2309    """The hash of the source operation"""
 2310    hash: Hash!
 2311}
 2312
 2313"""CommentHistoryStep hold one version of a message in the history"""
 2314type CommentHistoryStep {
 2315    message: String!
 2316    date: Time!
 2317}
 2318
 2319# Connection
 2320
 2321"""The connection type for TimelineItem"""
 2322type TimelineItemConnection {
 2323    edges: [TimelineItemEdge!]!
 2324    nodes: [TimelineItem!]!
 2325    pageInfo: PageInfo!
 2326    totalCount: Int!
 2327}
 2328
 2329"""Represent a TimelineItem"""
 2330type TimelineItemEdge {
 2331    cursor: String!
 2332    node: TimelineItem!
 2333}
 2334
 2335# Items
 2336
 2337"""CreateTimelineItem is a TimelineItem that represent the creation of a bug and its message edition history"""
 2338type CreateTimelineItem implements TimelineItem & Authored {
 2339    """The hash of the source operation"""
 2340    hash: Hash!
 2341    author: Identity!
 2342    message: String!
 2343    messageIsEmpty: Boolean!
 2344    files: [Hash!]!
 2345    createdAt: Time!
 2346    lastEdit: Time!
 2347    edited: Boolean!
 2348    history: [CommentHistoryStep!]!
 2349}
 2350
 2351"""AddCommentTimelineItem is a TimelineItem that represent a Comment and its edition history"""
 2352type AddCommentTimelineItem implements TimelineItem & Authored {
 2353    """The hash of the source operation"""
 2354    hash: Hash!
 2355    author: Identity!
 2356    message: String!
 2357    messageIsEmpty: Boolean!
 2358    files: [Hash!]!
 2359    createdAt: Time!
 2360    lastEdit: Time!
 2361    edited: Boolean!
 2362    history: [CommentHistoryStep!]!
 2363}
 2364
 2365"""LabelChangeTimelineItem is a TimelineItem that represent a change in the labels of a bug"""
 2366type LabelChangeTimelineItem implements TimelineItem & Authored {
 2367    """The hash of the source operation"""
 2368    hash: Hash!
 2369    author: Identity!
 2370    date: Time!
 2371    added: [Label!]!
 2372    removed: [Label!]!
 2373}
 2374
 2375"""SetStatusTimelineItem is a TimelineItem that represent a change in the status of a bug"""
 2376type SetStatusTimelineItem implements TimelineItem & Authored {
 2377    """The hash of the source operation"""
 2378    hash: Hash!
 2379    author: Identity!
 2380    date: Time!
 2381    status: Status!
 2382}
 2383
 2384"""LabelChangeTimelineItem is a TimelineItem that represent a change in the title of a bug"""
 2385type SetTitleTimelineItem implements TimelineItem & Authored {
 2386    """The hash of the source operation"""
 2387    hash: Hash!
 2388    author: Identity!
 2389    date: Time!
 2390    title: String!
 2391    was: String!
 2392}
 2393`},
 2394	&ast.Source{Name: "schema/types.graphql", Input: `scalar Time
 2395scalar Hash
 2396
 2397"""Defines a color by red, green and blue components."""
 2398type Color {
 2399    """Red component of the color."""
 2400    R: Int!
 2401    """Green component of the color."""
 2402    G: Int!
 2403    """Blue component of the color."""
 2404    B: Int!
 2405}
 2406
 2407"""Label for a bug."""
 2408type Label {
 2409    """The name of the label."""
 2410    name: String!
 2411    """Color of the label."""
 2412    color: Color!
 2413}
 2414
 2415"""Information about pagination in a connection."""
 2416type PageInfo {
 2417    """When paginating forwards, are there more items?"""
 2418    hasNextPage: Boolean!
 2419    """When paginating backwards, are there more items?"""
 2420    hasPreviousPage: Boolean!
 2421    """When paginating backwards, the cursor to continue."""
 2422    startCursor: String!
 2423    """When paginating forwards, the cursor to continue."""
 2424    endCursor: String!
 2425}
 2426
 2427"""An object that has an author."""
 2428interface Authored {
 2429    """The author of this object."""
 2430    author: Identity!
 2431}
 2432`},
 2433)
 2434
 2435// endregion ************************** generated!.gotpl **************************
 2436
 2437// region    ***************************** args.gotpl *****************************
 2438
 2439func (ec *executionContext) field_Bug_actors_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2440	var err error
 2441	args := map[string]interface{}{}
 2442	var arg0 *string
 2443	if tmp, ok := rawArgs["after"]; ok {
 2444		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2445		if err != nil {
 2446			return nil, err
 2447		}
 2448	}
 2449	args["after"] = arg0
 2450	var arg1 *string
 2451	if tmp, ok := rawArgs["before"]; ok {
 2452		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2453		if err != nil {
 2454			return nil, err
 2455		}
 2456	}
 2457	args["before"] = arg1
 2458	var arg2 *int
 2459	if tmp, ok := rawArgs["first"]; ok {
 2460		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2461		if err != nil {
 2462			return nil, err
 2463		}
 2464	}
 2465	args["first"] = arg2
 2466	var arg3 *int
 2467	if tmp, ok := rawArgs["last"]; ok {
 2468		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2469		if err != nil {
 2470			return nil, err
 2471		}
 2472	}
 2473	args["last"] = arg3
 2474	return args, nil
 2475}
 2476
 2477func (ec *executionContext) field_Bug_comments_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2478	var err error
 2479	args := map[string]interface{}{}
 2480	var arg0 *string
 2481	if tmp, ok := rawArgs["after"]; ok {
 2482		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2483		if err != nil {
 2484			return nil, err
 2485		}
 2486	}
 2487	args["after"] = arg0
 2488	var arg1 *string
 2489	if tmp, ok := rawArgs["before"]; ok {
 2490		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2491		if err != nil {
 2492			return nil, err
 2493		}
 2494	}
 2495	args["before"] = arg1
 2496	var arg2 *int
 2497	if tmp, ok := rawArgs["first"]; ok {
 2498		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2499		if err != nil {
 2500			return nil, err
 2501		}
 2502	}
 2503	args["first"] = arg2
 2504	var arg3 *int
 2505	if tmp, ok := rawArgs["last"]; ok {
 2506		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2507		if err != nil {
 2508			return nil, err
 2509		}
 2510	}
 2511	args["last"] = arg3
 2512	return args, nil
 2513}
 2514
 2515func (ec *executionContext) field_Bug_operations_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2516	var err error
 2517	args := map[string]interface{}{}
 2518	var arg0 *string
 2519	if tmp, ok := rawArgs["after"]; ok {
 2520		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2521		if err != nil {
 2522			return nil, err
 2523		}
 2524	}
 2525	args["after"] = arg0
 2526	var arg1 *string
 2527	if tmp, ok := rawArgs["before"]; ok {
 2528		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2529		if err != nil {
 2530			return nil, err
 2531		}
 2532	}
 2533	args["before"] = arg1
 2534	var arg2 *int
 2535	if tmp, ok := rawArgs["first"]; ok {
 2536		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2537		if err != nil {
 2538			return nil, err
 2539		}
 2540	}
 2541	args["first"] = arg2
 2542	var arg3 *int
 2543	if tmp, ok := rawArgs["last"]; ok {
 2544		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2545		if err != nil {
 2546			return nil, err
 2547		}
 2548	}
 2549	args["last"] = arg3
 2550	return args, nil
 2551}
 2552
 2553func (ec *executionContext) field_Bug_participants_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2554	var err error
 2555	args := map[string]interface{}{}
 2556	var arg0 *string
 2557	if tmp, ok := rawArgs["after"]; ok {
 2558		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2559		if err != nil {
 2560			return nil, err
 2561		}
 2562	}
 2563	args["after"] = arg0
 2564	var arg1 *string
 2565	if tmp, ok := rawArgs["before"]; ok {
 2566		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2567		if err != nil {
 2568			return nil, err
 2569		}
 2570	}
 2571	args["before"] = arg1
 2572	var arg2 *int
 2573	if tmp, ok := rawArgs["first"]; ok {
 2574		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2575		if err != nil {
 2576			return nil, err
 2577		}
 2578	}
 2579	args["first"] = arg2
 2580	var arg3 *int
 2581	if tmp, ok := rawArgs["last"]; ok {
 2582		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2583		if err != nil {
 2584			return nil, err
 2585		}
 2586	}
 2587	args["last"] = arg3
 2588	return args, nil
 2589}
 2590
 2591func (ec *executionContext) field_Bug_timeline_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2592	var err error
 2593	args := map[string]interface{}{}
 2594	var arg0 *string
 2595	if tmp, ok := rawArgs["after"]; ok {
 2596		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2597		if err != nil {
 2598			return nil, err
 2599		}
 2600	}
 2601	args["after"] = arg0
 2602	var arg1 *string
 2603	if tmp, ok := rawArgs["before"]; ok {
 2604		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2605		if err != nil {
 2606			return nil, err
 2607		}
 2608	}
 2609	args["before"] = arg1
 2610	var arg2 *int
 2611	if tmp, ok := rawArgs["first"]; ok {
 2612		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2613		if err != nil {
 2614			return nil, err
 2615		}
 2616	}
 2617	args["first"] = arg2
 2618	var arg3 *int
 2619	if tmp, ok := rawArgs["last"]; ok {
 2620		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2621		if err != nil {
 2622			return nil, err
 2623		}
 2624	}
 2625	args["last"] = arg3
 2626	return args, nil
 2627}
 2628
 2629func (ec *executionContext) field_Mutation_addComment_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2630	var err error
 2631	args := map[string]interface{}{}
 2632	var arg0 models.AddCommentInput
 2633	if tmp, ok := rawArgs["input"]; ok {
 2634		arg0, err = ec.unmarshalNAddCommentInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentInput(ctx, tmp)
 2635		if err != nil {
 2636			return nil, err
 2637		}
 2638	}
 2639	args["input"] = arg0
 2640	return args, nil
 2641}
 2642
 2643func (ec *executionContext) field_Mutation_changeLabels_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2644	var err error
 2645	args := map[string]interface{}{}
 2646	var arg0 *models.ChangeLabelInput
 2647	if tmp, ok := rawArgs["input"]; ok {
 2648		arg0, err = ec.unmarshalOChangeLabelInput2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx, tmp)
 2649		if err != nil {
 2650			return nil, err
 2651		}
 2652	}
 2653	args["input"] = arg0
 2654	return args, nil
 2655}
 2656
 2657func (ec *executionContext) field_Mutation_closeBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2658	var err error
 2659	args := map[string]interface{}{}
 2660	var arg0 models.CloseBugInput
 2661	if tmp, ok := rawArgs["input"]; ok {
 2662		arg0, err = ec.unmarshalNCloseBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugInput(ctx, tmp)
 2663		if err != nil {
 2664			return nil, err
 2665		}
 2666	}
 2667	args["input"] = arg0
 2668	return args, nil
 2669}
 2670
 2671func (ec *executionContext) field_Mutation_commitAsNeeded_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2672	var err error
 2673	args := map[string]interface{}{}
 2674	var arg0 models.CommitAsNeededInput
 2675	if tmp, ok := rawArgs["input"]; ok {
 2676		arg0, err = ec.unmarshalNCommitAsNeededInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitAsNeededInput(ctx, tmp)
 2677		if err != nil {
 2678			return nil, err
 2679		}
 2680	}
 2681	args["input"] = arg0
 2682	return args, nil
 2683}
 2684
 2685func (ec *executionContext) field_Mutation_commit_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2686	var err error
 2687	args := map[string]interface{}{}
 2688	var arg0 models.CommitInput
 2689	if tmp, ok := rawArgs["input"]; ok {
 2690		arg0, err = ec.unmarshalNCommitInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitInput(ctx, tmp)
 2691		if err != nil {
 2692			return nil, err
 2693		}
 2694	}
 2695	args["input"] = arg0
 2696	return args, nil
 2697}
 2698
 2699func (ec *executionContext) field_Mutation_newBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2700	var err error
 2701	args := map[string]interface{}{}
 2702	var arg0 models.NewBugInput
 2703	if tmp, ok := rawArgs["input"]; ok {
 2704		arg0, err = ec.unmarshalNNewBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugInput(ctx, tmp)
 2705		if err != nil {
 2706			return nil, err
 2707		}
 2708	}
 2709	args["input"] = arg0
 2710	return args, nil
 2711}
 2712
 2713func (ec *executionContext) field_Mutation_openBug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2714	var err error
 2715	args := map[string]interface{}{}
 2716	var arg0 models.OpenBugInput
 2717	if tmp, ok := rawArgs["input"]; ok {
 2718		arg0, err = ec.unmarshalNOpenBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugInput(ctx, tmp)
 2719		if err != nil {
 2720			return nil, err
 2721		}
 2722	}
 2723	args["input"] = arg0
 2724	return args, nil
 2725}
 2726
 2727func (ec *executionContext) field_Mutation_setTitle_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2728	var err error
 2729	args := map[string]interface{}{}
 2730	var arg0 models.SetTitleInput
 2731	if tmp, ok := rawArgs["input"]; ok {
 2732		arg0, err = ec.unmarshalNSetTitleInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitleInput(ctx, tmp)
 2733		if err != nil {
 2734			return nil, err
 2735		}
 2736	}
 2737	args["input"] = arg0
 2738	return args, nil
 2739}
 2740
 2741func (ec *executionContext) field_Query___type_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2742	var err error
 2743	args := map[string]interface{}{}
 2744	var arg0 string
 2745	if tmp, ok := rawArgs["name"]; ok {
 2746		arg0, err = ec.unmarshalNString2string(ctx, tmp)
 2747		if err != nil {
 2748			return nil, err
 2749		}
 2750	}
 2751	args["name"] = arg0
 2752	return args, nil
 2753}
 2754
 2755func (ec *executionContext) field_Query_repository_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2756	var err error
 2757	args := map[string]interface{}{}
 2758	var arg0 string
 2759	if tmp, ok := rawArgs["ref"]; ok {
 2760		arg0, err = ec.unmarshalNString2string(ctx, tmp)
 2761		if err != nil {
 2762			return nil, err
 2763		}
 2764	}
 2765	args["ref"] = arg0
 2766	return args, nil
 2767}
 2768
 2769func (ec *executionContext) field_Repository_allBugs_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2770	var err error
 2771	args := map[string]interface{}{}
 2772	var arg0 *string
 2773	if tmp, ok := rawArgs["after"]; ok {
 2774		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2775		if err != nil {
 2776			return nil, err
 2777		}
 2778	}
 2779	args["after"] = arg0
 2780	var arg1 *string
 2781	if tmp, ok := rawArgs["before"]; ok {
 2782		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2783		if err != nil {
 2784			return nil, err
 2785		}
 2786	}
 2787	args["before"] = arg1
 2788	var arg2 *int
 2789	if tmp, ok := rawArgs["first"]; ok {
 2790		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2791		if err != nil {
 2792			return nil, err
 2793		}
 2794	}
 2795	args["first"] = arg2
 2796	var arg3 *int
 2797	if tmp, ok := rawArgs["last"]; ok {
 2798		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2799		if err != nil {
 2800			return nil, err
 2801		}
 2802	}
 2803	args["last"] = arg3
 2804	var arg4 *string
 2805	if tmp, ok := rawArgs["query"]; ok {
 2806		arg4, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2807		if err != nil {
 2808			return nil, err
 2809		}
 2810	}
 2811	args["query"] = arg4
 2812	return args, nil
 2813}
 2814
 2815func (ec *executionContext) field_Repository_allIdentities_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2816	var err error
 2817	args := map[string]interface{}{}
 2818	var arg0 *string
 2819	if tmp, ok := rawArgs["after"]; ok {
 2820		arg0, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2821		if err != nil {
 2822			return nil, err
 2823		}
 2824	}
 2825	args["after"] = arg0
 2826	var arg1 *string
 2827	if tmp, ok := rawArgs["before"]; ok {
 2828		arg1, err = ec.unmarshalOString2ᚖstring(ctx, tmp)
 2829		if err != nil {
 2830			return nil, err
 2831		}
 2832	}
 2833	args["before"] = arg1
 2834	var arg2 *int
 2835	if tmp, ok := rawArgs["first"]; ok {
 2836		arg2, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2837		if err != nil {
 2838			return nil, err
 2839		}
 2840	}
 2841	args["first"] = arg2
 2842	var arg3 *int
 2843	if tmp, ok := rawArgs["last"]; ok {
 2844		arg3, err = ec.unmarshalOInt2ᚖint(ctx, tmp)
 2845		if err != nil {
 2846			return nil, err
 2847		}
 2848	}
 2849	args["last"] = arg3
 2850	return args, nil
 2851}
 2852
 2853func (ec *executionContext) field_Repository_bug_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2854	var err error
 2855	args := map[string]interface{}{}
 2856	var arg0 string
 2857	if tmp, ok := rawArgs["prefix"]; ok {
 2858		arg0, err = ec.unmarshalNString2string(ctx, tmp)
 2859		if err != nil {
 2860			return nil, err
 2861		}
 2862	}
 2863	args["prefix"] = arg0
 2864	return args, nil
 2865}
 2866
 2867func (ec *executionContext) field_Repository_identity_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2868	var err error
 2869	args := map[string]interface{}{}
 2870	var arg0 string
 2871	if tmp, ok := rawArgs["prefix"]; ok {
 2872		arg0, err = ec.unmarshalNString2string(ctx, tmp)
 2873		if err != nil {
 2874			return nil, err
 2875		}
 2876	}
 2877	args["prefix"] = arg0
 2878	return args, nil
 2879}
 2880
 2881func (ec *executionContext) field___Type_enumValues_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2882	var err error
 2883	args := map[string]interface{}{}
 2884	var arg0 bool
 2885	if tmp, ok := rawArgs["includeDeprecated"]; ok {
 2886		arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
 2887		if err != nil {
 2888			return nil, err
 2889		}
 2890	}
 2891	args["includeDeprecated"] = arg0
 2892	return args, nil
 2893}
 2894
 2895func (ec *executionContext) field___Type_fields_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
 2896	var err error
 2897	args := map[string]interface{}{}
 2898	var arg0 bool
 2899	if tmp, ok := rawArgs["includeDeprecated"]; ok {
 2900		arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
 2901		if err != nil {
 2902			return nil, err
 2903		}
 2904	}
 2905	args["includeDeprecated"] = arg0
 2906	return args, nil
 2907}
 2908
 2909// endregion ***************************** args.gotpl *****************************
 2910
 2911// region    **************************** field.gotpl *****************************
 2912
 2913func (ec *executionContext) _AddCommentOperation_hash(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) graphql.Marshaler {
 2914	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 2915	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 2916	rctx := &graphql.ResolverContext{
 2917		Object:   "AddCommentOperation",
 2918		Field:    field,
 2919		Args:     nil,
 2920		IsMethod: true,
 2921	}
 2922	ctx = graphql.WithResolverContext(ctx, rctx)
 2923	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 2924	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 2925		ctx = rctx // use context from middleware stack in children
 2926		return obj.Hash()
 2927	})
 2928	if resTmp == nil {
 2929		if !ec.HasError(rctx) {
 2930			ec.Errorf(ctx, "must not be null")
 2931		}
 2932		return graphql.Null
 2933	}
 2934	res := resTmp.(git.Hash)
 2935	rctx.Result = res
 2936	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 2937	return ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
 2938}
 2939
 2940func (ec *executionContext) _AddCommentOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) graphql.Marshaler {
 2941	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 2942	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 2943	rctx := &graphql.ResolverContext{
 2944		Object:   "AddCommentOperation",
 2945		Field:    field,
 2946		Args:     nil,
 2947		IsMethod: false,
 2948	}
 2949	ctx = graphql.WithResolverContext(ctx, rctx)
 2950	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 2951	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 2952		ctx = rctx // use context from middleware stack in children
 2953		return obj.Author, nil
 2954	})
 2955	if resTmp == nil {
 2956		if !ec.HasError(rctx) {
 2957			ec.Errorf(ctx, "must not be null")
 2958		}
 2959		return graphql.Null
 2960	}
 2961	res := resTmp.(identity.Interface)
 2962	rctx.Result = res
 2963	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 2964	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
 2965}
 2966
 2967func (ec *executionContext) _AddCommentOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) graphql.Marshaler {
 2968	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 2969	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 2970	rctx := &graphql.ResolverContext{
 2971		Object:   "AddCommentOperation",
 2972		Field:    field,
 2973		Args:     nil,
 2974		IsMethod: true,
 2975	}
 2976	ctx = graphql.WithResolverContext(ctx, rctx)
 2977	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 2978	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 2979		ctx = rctx // use context from middleware stack in children
 2980		return ec.resolvers.AddCommentOperation().Date(rctx, obj)
 2981	})
 2982	if resTmp == nil {
 2983		if !ec.HasError(rctx) {
 2984			ec.Errorf(ctx, "must not be null")
 2985		}
 2986		return graphql.Null
 2987	}
 2988	res := resTmp.(*time.Time)
 2989	rctx.Result = res
 2990	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 2991	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 2992}
 2993
 2994func (ec *executionContext) _AddCommentOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) graphql.Marshaler {
 2995	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 2996	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 2997	rctx := &graphql.ResolverContext{
 2998		Object:   "AddCommentOperation",
 2999		Field:    field,
 3000		Args:     nil,
 3001		IsMethod: false,
 3002	}
 3003	ctx = graphql.WithResolverContext(ctx, rctx)
 3004	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3005	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 3006		ctx = rctx // use context from middleware stack in children
 3007		return obj.Message, nil
 3008	})
 3009	if resTmp == nil {
 3010		if !ec.HasError(rctx) {
 3011			ec.Errorf(ctx, "must not be null")
 3012		}
 3013		return graphql.Null
 3014	}
 3015	res := resTmp.(string)
 3016	rctx.Result = res
 3017	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3018	return ec.marshalNString2string(ctx, field.Selections, res)
 3019}
 3020
 3021func (ec *executionContext) _AddCommentOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentOperation) graphql.Marshaler {
 3022	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3023	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 3024	rctx := &graphql.ResolverContext{
 3025		Object:   "AddCommentOperation",
 3026		Field:    field,
 3027		Args:     nil,
 3028		IsMethod: false,
 3029	}
 3030	ctx = graphql.WithResolverContext(ctx, rctx)
 3031	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3032	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 3033		ctx = rctx // use context from middleware stack in children
 3034		return obj.Files, nil
 3035	})
 3036	if resTmp == nil {
 3037		if !ec.HasError(rctx) {
 3038			ec.Errorf(ctx, "must not be null")
 3039		}
 3040		return graphql.Null
 3041	}
 3042	res := resTmp.([]git.Hash)
 3043	rctx.Result = res
 3044	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3045	return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
 3046}
 3047
 3048func (ec *executionContext) _AddCommentPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) graphql.Marshaler {
 3049	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3050	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 3051	rctx := &graphql.ResolverContext{
 3052		Object:   "AddCommentPayload",
 3053		Field:    field,
 3054		Args:     nil,
 3055		IsMethod: false,
 3056	}
 3057	ctx = graphql.WithResolverContext(ctx, rctx)
 3058	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3059	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 3060		ctx = rctx // use context from middleware stack in children
 3061		return obj.ClientMutationID, nil
 3062	})
 3063	if resTmp == nil {
 3064		return graphql.Null
 3065	}
 3066	res := resTmp.(*string)
 3067	rctx.Result = res
 3068	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3069	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 3070}
 3071
 3072func (ec *executionContext) _AddCommentPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) graphql.Marshaler {
 3073	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3074	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 3075	rctx := &graphql.ResolverContext{
 3076		Object:   "AddCommentPayload",
 3077		Field:    field,
 3078		Args:     nil,
 3079		IsMethod: false,
 3080	}
 3081	ctx = graphql.WithResolverContext(ctx, rctx)
 3082	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3083	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 3084		ctx = rctx // use context from middleware stack in children
 3085		return obj.Bug, nil
 3086	})
 3087	if resTmp == nil {
 3088		if !ec.HasError(rctx) {
 3089			ec.Errorf(ctx, "must not be null")
 3090		}
 3091		return graphql.Null
 3092	}
 3093	res := resTmp.(*bug.Snapshot)
 3094	rctx.Result = res
 3095	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3096	return ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
 3097}
 3098
 3099func (ec *executionContext) _AddCommentPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.AddCommentPayload) graphql.Marshaler {
 3100	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3101	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 3102	rctx := &graphql.ResolverContext{
 3103		Object:   "AddCommentPayload",
 3104		Field:    field,
 3105		Args:     nil,
 3106		IsMethod: false,
 3107	}
 3108	ctx = graphql.WithResolverContext(ctx, rctx)
 3109	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3110	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 3111		ctx = rctx // use context from middleware stack in children
 3112		return obj.Operation, nil
 3113	})
 3114	if resTmp == nil {
 3115		if !ec.HasError(rctx) {
 3116			ec.Errorf(ctx, "must not be null")
 3117		}
 3118		return graphql.Null
 3119	}
 3120	res := resTmp.(*bug.AddCommentOperation)
 3121	rctx.Result = res
 3122	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3123	return ec.marshalNAddCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx, field.Selections, res)
 3124}
 3125
 3126func (ec *executionContext) _AddCommentTimelineItem_hash(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
 3127	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3128	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 3129	rctx := &graphql.ResolverContext{
 3130		Object:   "AddCommentTimelineItem",
 3131		Field:    field,
 3132		Args:     nil,
 3133		IsMethod: true,
 3134	}
 3135	ctx = graphql.WithResolverContext(ctx, rctx)
 3136	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3137	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 3138		ctx = rctx // use context from middleware stack in children
 3139		return obj.Hash(), nil
 3140	})
 3141	if resTmp == nil {
 3142		if !ec.HasError(rctx) {
 3143			ec.Errorf(ctx, "must not be null")
 3144		}
 3145		return graphql.Null
 3146	}
 3147	res := resTmp.(git.Hash)
 3148	rctx.Result = res
 3149	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3150	return ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
 3151}
 3152
 3153func (ec *executionContext) _AddCommentTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
 3154	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3155	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 3156	rctx := &graphql.ResolverContext{
 3157		Object:   "AddCommentTimelineItem",
 3158		Field:    field,
 3159		Args:     nil,
 3160		IsMethod: false,
 3161	}
 3162	ctx = graphql.WithResolverContext(ctx, rctx)
 3163	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3164	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 3165		ctx = rctx // use context from middleware stack in children
 3166		return obj.Author, nil
 3167	})
 3168	if resTmp == nil {
 3169		if !ec.HasError(rctx) {
 3170			ec.Errorf(ctx, "must not be null")
 3171		}
 3172		return graphql.Null
 3173	}
 3174	res := resTmp.(identity.Interface)
 3175	rctx.Result = res
 3176	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3177	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
 3178}
 3179
 3180func (ec *executionContext) _AddCommentTimelineItem_message(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
 3181	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3182	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 3183	rctx := &graphql.ResolverContext{
 3184		Object:   "AddCommentTimelineItem",
 3185		Field:    field,
 3186		Args:     nil,
 3187		IsMethod: false,
 3188	}
 3189	ctx = graphql.WithResolverContext(ctx, rctx)
 3190	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3191	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 3192		ctx = rctx // use context from middleware stack in children
 3193		return obj.Message, nil
 3194	})
 3195	if resTmp == nil {
 3196		if !ec.HasError(rctx) {
 3197			ec.Errorf(ctx, "must not be null")
 3198		}
 3199		return graphql.Null
 3200	}
 3201	res := resTmp.(string)
 3202	rctx.Result = res
 3203	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3204	return ec.marshalNString2string(ctx, field.Selections, res)
 3205}
 3206
 3207func (ec *executionContext) _AddCommentTimelineItem_messageIsEmpty(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
 3208	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3209	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 3210	rctx := &graphql.ResolverContext{
 3211		Object:   "AddCommentTimelineItem",
 3212		Field:    field,
 3213		Args:     nil,
 3214		IsMethod: true,
 3215	}
 3216	ctx = graphql.WithResolverContext(ctx, rctx)
 3217	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3218	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 3219		ctx = rctx // use context from middleware stack in children
 3220		return obj.MessageIsEmpty(), nil
 3221	})
 3222	if resTmp == nil {
 3223		if !ec.HasError(rctx) {
 3224			ec.Errorf(ctx, "must not be null")
 3225		}
 3226		return graphql.Null
 3227	}
 3228	res := resTmp.(bool)
 3229	rctx.Result = res
 3230	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3231	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 3232}
 3233
 3234func (ec *executionContext) _AddCommentTimelineItem_files(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
 3235	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3236	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 3237	rctx := &graphql.ResolverContext{
 3238		Object:   "AddCommentTimelineItem",
 3239		Field:    field,
 3240		Args:     nil,
 3241		IsMethod: false,
 3242	}
 3243	ctx = graphql.WithResolverContext(ctx, rctx)
 3244	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3245	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 3246		ctx = rctx // use context from middleware stack in children
 3247		return obj.Files, nil
 3248	})
 3249	if resTmp == nil {
 3250		if !ec.HasError(rctx) {
 3251			ec.Errorf(ctx, "must not be null")
 3252		}
 3253		return graphql.Null
 3254	}
 3255	res := resTmp.([]git.Hash)
 3256	rctx.Result = res
 3257	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3258	return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
 3259}
 3260
 3261func (ec *executionContext) _AddCommentTimelineItem_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
 3262	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3263	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 3264	rctx := &graphql.ResolverContext{
 3265		Object:   "AddCommentTimelineItem",
 3266		Field:    field,
 3267		Args:     nil,
 3268		IsMethod: true,
 3269	}
 3270	ctx = graphql.WithResolverContext(ctx, rctx)
 3271	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3272	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 3273		ctx = rctx // use context from middleware stack in children
 3274		return ec.resolvers.AddCommentTimelineItem().CreatedAt(rctx, obj)
 3275	})
 3276	if resTmp == nil {
 3277		if !ec.HasError(rctx) {
 3278			ec.Errorf(ctx, "must not be null")
 3279		}
 3280		return graphql.Null
 3281	}
 3282	res := resTmp.(*time.Time)
 3283	rctx.Result = res
 3284	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3285	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 3286}
 3287
 3288func (ec *executionContext) _AddCommentTimelineItem_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
 3289	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3290	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 3291	rctx := &graphql.ResolverContext{
 3292		Object:   "AddCommentTimelineItem",
 3293		Field:    field,
 3294		Args:     nil,
 3295		IsMethod: true,
 3296	}
 3297	ctx = graphql.WithResolverContext(ctx, rctx)
 3298	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3299	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 3300		ctx = rctx // use context from middleware stack in children
 3301		return ec.resolvers.AddCommentTimelineItem().LastEdit(rctx, obj)
 3302	})
 3303	if resTmp == nil {
 3304		if !ec.HasError(rctx) {
 3305			ec.Errorf(ctx, "must not be null")
 3306		}
 3307		return graphql.Null
 3308	}
 3309	res := resTmp.(*time.Time)
 3310	rctx.Result = res
 3311	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3312	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 3313}
 3314
 3315func (ec *executionContext) _AddCommentTimelineItem_edited(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
 3316	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3317	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 3318	rctx := &graphql.ResolverContext{
 3319		Object:   "AddCommentTimelineItem",
 3320		Field:    field,
 3321		Args:     nil,
 3322		IsMethod: true,
 3323	}
 3324	ctx = graphql.WithResolverContext(ctx, rctx)
 3325	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3326	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 3327		ctx = rctx // use context from middleware stack in children
 3328		return obj.Edited(), nil
 3329	})
 3330	if resTmp == nil {
 3331		if !ec.HasError(rctx) {
 3332			ec.Errorf(ctx, "must not be null")
 3333		}
 3334		return graphql.Null
 3335	}
 3336	res := resTmp.(bool)
 3337	rctx.Result = res
 3338	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3339	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 3340}
 3341
 3342func (ec *executionContext) _AddCommentTimelineItem_history(ctx context.Context, field graphql.CollectedField, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
 3343	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3344	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 3345	rctx := &graphql.ResolverContext{
 3346		Object:   "AddCommentTimelineItem",
 3347		Field:    field,
 3348		Args:     nil,
 3349		IsMethod: false,
 3350	}
 3351	ctx = graphql.WithResolverContext(ctx, rctx)
 3352	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3353	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 3354		ctx = rctx // use context from middleware stack in children
 3355		return obj.History, nil
 3356	})
 3357	if resTmp == nil {
 3358		if !ec.HasError(rctx) {
 3359			ec.Errorf(ctx, "must not be null")
 3360		}
 3361		return graphql.Null
 3362	}
 3363	res := resTmp.([]bug.CommentHistoryStep)
 3364	rctx.Result = res
 3365	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3366	return ec.marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx, field.Selections, res)
 3367}
 3368
 3369func (ec *executionContext) _Bug_id(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
 3370	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3371	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 3372	rctx := &graphql.ResolverContext{
 3373		Object:   "Bug",
 3374		Field:    field,
 3375		Args:     nil,
 3376		IsMethod: true,
 3377	}
 3378	ctx = graphql.WithResolverContext(ctx, rctx)
 3379	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3380	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 3381		ctx = rctx // use context from middleware stack in children
 3382		return obj.Id(), nil
 3383	})
 3384	if resTmp == nil {
 3385		if !ec.HasError(rctx) {
 3386			ec.Errorf(ctx, "must not be null")
 3387		}
 3388		return graphql.Null
 3389	}
 3390	res := resTmp.(string)
 3391	rctx.Result = res
 3392	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3393	return ec.marshalNString2string(ctx, field.Selections, res)
 3394}
 3395
 3396func (ec *executionContext) _Bug_humanId(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
 3397	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3398	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 3399	rctx := &graphql.ResolverContext{
 3400		Object:   "Bug",
 3401		Field:    field,
 3402		Args:     nil,
 3403		IsMethod: true,
 3404	}
 3405	ctx = graphql.WithResolverContext(ctx, rctx)
 3406	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3407	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 3408		ctx = rctx // use context from middleware stack in children
 3409		return obj.HumanId(), nil
 3410	})
 3411	if resTmp == nil {
 3412		if !ec.HasError(rctx) {
 3413			ec.Errorf(ctx, "must not be null")
 3414		}
 3415		return graphql.Null
 3416	}
 3417	res := resTmp.(string)
 3418	rctx.Result = res
 3419	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3420	return ec.marshalNString2string(ctx, field.Selections, res)
 3421}
 3422
 3423func (ec *executionContext) _Bug_status(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
 3424	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3425	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 3426	rctx := &graphql.ResolverContext{
 3427		Object:   "Bug",
 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 := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 3435		ctx = rctx // use context from middleware stack in children
 3436		return ec.resolvers.Bug().Status(rctx, obj)
 3437	})
 3438	if resTmp == nil {
 3439		if !ec.HasError(rctx) {
 3440			ec.Errorf(ctx, "must not be null")
 3441		}
 3442		return graphql.Null
 3443	}
 3444	res := resTmp.(models.Status)
 3445	rctx.Result = res
 3446	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3447	return ec.marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx, field.Selections, res)
 3448}
 3449
 3450func (ec *executionContext) _Bug_title(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
 3451	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3452	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 3453	rctx := &graphql.ResolverContext{
 3454		Object:   "Bug",
 3455		Field:    field,
 3456		Args:     nil,
 3457		IsMethod: false,
 3458	}
 3459	ctx = graphql.WithResolverContext(ctx, rctx)
 3460	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3461	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 3462		ctx = rctx // use context from middleware stack in children
 3463		return obj.Title, nil
 3464	})
 3465	if resTmp == nil {
 3466		if !ec.HasError(rctx) {
 3467			ec.Errorf(ctx, "must not be null")
 3468		}
 3469		return graphql.Null
 3470	}
 3471	res := resTmp.(string)
 3472	rctx.Result = res
 3473	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3474	return ec.marshalNString2string(ctx, field.Selections, res)
 3475}
 3476
 3477func (ec *executionContext) _Bug_labels(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
 3478	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3479	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 3480	rctx := &graphql.ResolverContext{
 3481		Object:   "Bug",
 3482		Field:    field,
 3483		Args:     nil,
 3484		IsMethod: false,
 3485	}
 3486	ctx = graphql.WithResolverContext(ctx, rctx)
 3487	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3488	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 3489		ctx = rctx // use context from middleware stack in children
 3490		return obj.Labels, nil
 3491	})
 3492	if resTmp == nil {
 3493		if !ec.HasError(rctx) {
 3494			ec.Errorf(ctx, "must not be null")
 3495		}
 3496		return graphql.Null
 3497	}
 3498	res := resTmp.([]bug.Label)
 3499	rctx.Result = res
 3500	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3501	return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
 3502}
 3503
 3504func (ec *executionContext) _Bug_author(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
 3505	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3506	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 3507	rctx := &graphql.ResolverContext{
 3508		Object:   "Bug",
 3509		Field:    field,
 3510		Args:     nil,
 3511		IsMethod: false,
 3512	}
 3513	ctx = graphql.WithResolverContext(ctx, rctx)
 3514	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3515	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 3516		ctx = rctx // use context from middleware stack in children
 3517		return obj.Author, nil
 3518	})
 3519	if resTmp == nil {
 3520		if !ec.HasError(rctx) {
 3521			ec.Errorf(ctx, "must not be null")
 3522		}
 3523		return graphql.Null
 3524	}
 3525	res := resTmp.(identity.Interface)
 3526	rctx.Result = res
 3527	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3528	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
 3529}
 3530
 3531func (ec *executionContext) _Bug_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
 3532	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3533	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 3534	rctx := &graphql.ResolverContext{
 3535		Object:   "Bug",
 3536		Field:    field,
 3537		Args:     nil,
 3538		IsMethod: false,
 3539	}
 3540	ctx = graphql.WithResolverContext(ctx, rctx)
 3541	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3542	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 3543		ctx = rctx // use context from middleware stack in children
 3544		return obj.CreatedAt, nil
 3545	})
 3546	if resTmp == nil {
 3547		if !ec.HasError(rctx) {
 3548			ec.Errorf(ctx, "must not be null")
 3549		}
 3550		return graphql.Null
 3551	}
 3552	res := resTmp.(time.Time)
 3553	rctx.Result = res
 3554	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3555	return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
 3556}
 3557
 3558func (ec *executionContext) _Bug_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
 3559	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3560	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 3561	rctx := &graphql.ResolverContext{
 3562		Object:   "Bug",
 3563		Field:    field,
 3564		Args:     nil,
 3565		IsMethod: true,
 3566	}
 3567	ctx = graphql.WithResolverContext(ctx, rctx)
 3568	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3569	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 3570		ctx = rctx // use context from middleware stack in children
 3571		return ec.resolvers.Bug().LastEdit(rctx, obj)
 3572	})
 3573	if resTmp == nil {
 3574		if !ec.HasError(rctx) {
 3575			ec.Errorf(ctx, "must not be null")
 3576		}
 3577		return graphql.Null
 3578	}
 3579	res := resTmp.(*time.Time)
 3580	rctx.Result = res
 3581	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3582	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 3583}
 3584
 3585func (ec *executionContext) _Bug_actors(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
 3586	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3587	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 3588	rctx := &graphql.ResolverContext{
 3589		Object:   "Bug",
 3590		Field:    field,
 3591		Args:     nil,
 3592		IsMethod: true,
 3593	}
 3594	ctx = graphql.WithResolverContext(ctx, rctx)
 3595	rawArgs := field.ArgumentMap(ec.Variables)
 3596	args, err := ec.field_Bug_actors_args(ctx, rawArgs)
 3597	if err != nil {
 3598		ec.Error(ctx, err)
 3599		return graphql.Null
 3600	}
 3601	rctx.Args = args
 3602	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3603	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 3604		ctx = rctx // use context from middleware stack in children
 3605		return ec.resolvers.Bug().Actors(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
 3606	})
 3607	if resTmp == nil {
 3608		if !ec.HasError(rctx) {
 3609			ec.Errorf(ctx, "must not be null")
 3610		}
 3611		return graphql.Null
 3612	}
 3613	res := resTmp.(*models.IdentityConnection)
 3614	rctx.Result = res
 3615	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3616	return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
 3617}
 3618
 3619func (ec *executionContext) _Bug_participants(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
 3620	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3621	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 3622	rctx := &graphql.ResolverContext{
 3623		Object:   "Bug",
 3624		Field:    field,
 3625		Args:     nil,
 3626		IsMethod: true,
 3627	}
 3628	ctx = graphql.WithResolverContext(ctx, rctx)
 3629	rawArgs := field.ArgumentMap(ec.Variables)
 3630	args, err := ec.field_Bug_participants_args(ctx, rawArgs)
 3631	if err != nil {
 3632		ec.Error(ctx, err)
 3633		return graphql.Null
 3634	}
 3635	rctx.Args = args
 3636	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3637	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 3638		ctx = rctx // use context from middleware stack in children
 3639		return ec.resolvers.Bug().Participants(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
 3640	})
 3641	if resTmp == nil {
 3642		if !ec.HasError(rctx) {
 3643			ec.Errorf(ctx, "must not be null")
 3644		}
 3645		return graphql.Null
 3646	}
 3647	res := resTmp.(*models.IdentityConnection)
 3648	rctx.Result = res
 3649	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3650	return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
 3651}
 3652
 3653func (ec *executionContext) _Bug_comments(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
 3654	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3655	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 3656	rctx := &graphql.ResolverContext{
 3657		Object:   "Bug",
 3658		Field:    field,
 3659		Args:     nil,
 3660		IsMethod: true,
 3661	}
 3662	ctx = graphql.WithResolverContext(ctx, rctx)
 3663	rawArgs := field.ArgumentMap(ec.Variables)
 3664	args, err := ec.field_Bug_comments_args(ctx, rawArgs)
 3665	if err != nil {
 3666		ec.Error(ctx, err)
 3667		return graphql.Null
 3668	}
 3669	rctx.Args = args
 3670	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3671	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 3672		ctx = rctx // use context from middleware stack in children
 3673		return ec.resolvers.Bug().Comments(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
 3674	})
 3675	if resTmp == nil {
 3676		if !ec.HasError(rctx) {
 3677			ec.Errorf(ctx, "must not be null")
 3678		}
 3679		return graphql.Null
 3680	}
 3681	res := resTmp.(*models.CommentConnection)
 3682	rctx.Result = res
 3683	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3684	return ec.marshalNCommentConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentConnection(ctx, field.Selections, res)
 3685}
 3686
 3687func (ec *executionContext) _Bug_timeline(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
 3688	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3689	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 3690	rctx := &graphql.ResolverContext{
 3691		Object:   "Bug",
 3692		Field:    field,
 3693		Args:     nil,
 3694		IsMethod: true,
 3695	}
 3696	ctx = graphql.WithResolverContext(ctx, rctx)
 3697	rawArgs := field.ArgumentMap(ec.Variables)
 3698	args, err := ec.field_Bug_timeline_args(ctx, rawArgs)
 3699	if err != nil {
 3700		ec.Error(ctx, err)
 3701		return graphql.Null
 3702	}
 3703	rctx.Args = args
 3704	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3705	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 3706		ctx = rctx // use context from middleware stack in children
 3707		return ec.resolvers.Bug().Timeline(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
 3708	})
 3709	if resTmp == nil {
 3710		if !ec.HasError(rctx) {
 3711			ec.Errorf(ctx, "must not be null")
 3712		}
 3713		return graphql.Null
 3714	}
 3715	res := resTmp.(*models.TimelineItemConnection)
 3716	rctx.Result = res
 3717	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3718	return ec.marshalNTimelineItemConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx, field.Selections, res)
 3719}
 3720
 3721func (ec *executionContext) _Bug_operations(ctx context.Context, field graphql.CollectedField, obj *bug.Snapshot) graphql.Marshaler {
 3722	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3723	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 3724	rctx := &graphql.ResolverContext{
 3725		Object:   "Bug",
 3726		Field:    field,
 3727		Args:     nil,
 3728		IsMethod: true,
 3729	}
 3730	ctx = graphql.WithResolverContext(ctx, rctx)
 3731	rawArgs := field.ArgumentMap(ec.Variables)
 3732	args, err := ec.field_Bug_operations_args(ctx, rawArgs)
 3733	if err != nil {
 3734		ec.Error(ctx, err)
 3735		return graphql.Null
 3736	}
 3737	rctx.Args = args
 3738	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3739	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 3740		ctx = rctx // use context from middleware stack in children
 3741		return ec.resolvers.Bug().Operations(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
 3742	})
 3743	if resTmp == nil {
 3744		if !ec.HasError(rctx) {
 3745			ec.Errorf(ctx, "must not be null")
 3746		}
 3747		return graphql.Null
 3748	}
 3749	res := resTmp.(*models.OperationConnection)
 3750	rctx.Result = res
 3751	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3752	return ec.marshalNOperationConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationConnection(ctx, field.Selections, res)
 3753}
 3754
 3755func (ec *executionContext) _BugConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) graphql.Marshaler {
 3756	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3757	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 3758	rctx := &graphql.ResolverContext{
 3759		Object:   "BugConnection",
 3760		Field:    field,
 3761		Args:     nil,
 3762		IsMethod: false,
 3763	}
 3764	ctx = graphql.WithResolverContext(ctx, rctx)
 3765	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3766	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 3767		ctx = rctx // use context from middleware stack in children
 3768		return obj.Edges, nil
 3769	})
 3770	if resTmp == nil {
 3771		if !ec.HasError(rctx) {
 3772			ec.Errorf(ctx, "must not be null")
 3773		}
 3774		return graphql.Null
 3775	}
 3776	res := resTmp.([]*models.BugEdge)
 3777	rctx.Result = res
 3778	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3779	return ec.marshalNBugEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx, field.Selections, res)
 3780}
 3781
 3782func (ec *executionContext) _BugConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) graphql.Marshaler {
 3783	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3784	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 3785	rctx := &graphql.ResolverContext{
 3786		Object:   "BugConnection",
 3787		Field:    field,
 3788		Args:     nil,
 3789		IsMethod: false,
 3790	}
 3791	ctx = graphql.WithResolverContext(ctx, rctx)
 3792	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3793	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 3794		ctx = rctx // use context from middleware stack in children
 3795		return obj.Nodes, nil
 3796	})
 3797	if resTmp == nil {
 3798		if !ec.HasError(rctx) {
 3799			ec.Errorf(ctx, "must not be null")
 3800		}
 3801		return graphql.Null
 3802	}
 3803	res := resTmp.([]*bug.Snapshot)
 3804	rctx.Result = res
 3805	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3806	return ec.marshalNBug2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
 3807}
 3808
 3809func (ec *executionContext) _BugConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) graphql.Marshaler {
 3810	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3811	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 3812	rctx := &graphql.ResolverContext{
 3813		Object:   "BugConnection",
 3814		Field:    field,
 3815		Args:     nil,
 3816		IsMethod: false,
 3817	}
 3818	ctx = graphql.WithResolverContext(ctx, rctx)
 3819	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3820	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 3821		ctx = rctx // use context from middleware stack in children
 3822		return obj.PageInfo, nil
 3823	})
 3824	if resTmp == nil {
 3825		if !ec.HasError(rctx) {
 3826			ec.Errorf(ctx, "must not be null")
 3827		}
 3828		return graphql.Null
 3829	}
 3830	res := resTmp.(*models.PageInfo)
 3831	rctx.Result = res
 3832	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3833	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
 3834}
 3835
 3836func (ec *executionContext) _BugConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.BugConnection) graphql.Marshaler {
 3837	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3838	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 3839	rctx := &graphql.ResolverContext{
 3840		Object:   "BugConnection",
 3841		Field:    field,
 3842		Args:     nil,
 3843		IsMethod: false,
 3844	}
 3845	ctx = graphql.WithResolverContext(ctx, rctx)
 3846	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3847	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 3848		ctx = rctx // use context from middleware stack in children
 3849		return obj.TotalCount, nil
 3850	})
 3851	if resTmp == nil {
 3852		if !ec.HasError(rctx) {
 3853			ec.Errorf(ctx, "must not be null")
 3854		}
 3855		return graphql.Null
 3856	}
 3857	res := resTmp.(int)
 3858	rctx.Result = res
 3859	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3860	return ec.marshalNInt2int(ctx, field.Selections, res)
 3861}
 3862
 3863func (ec *executionContext) _BugEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.BugEdge) graphql.Marshaler {
 3864	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3865	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 3866	rctx := &graphql.ResolverContext{
 3867		Object:   "BugEdge",
 3868		Field:    field,
 3869		Args:     nil,
 3870		IsMethod: false,
 3871	}
 3872	ctx = graphql.WithResolverContext(ctx, rctx)
 3873	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3874	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 3875		ctx = rctx // use context from middleware stack in children
 3876		return obj.Cursor, nil
 3877	})
 3878	if resTmp == nil {
 3879		if !ec.HasError(rctx) {
 3880			ec.Errorf(ctx, "must not be null")
 3881		}
 3882		return graphql.Null
 3883	}
 3884	res := resTmp.(string)
 3885	rctx.Result = res
 3886	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3887	return ec.marshalNString2string(ctx, field.Selections, res)
 3888}
 3889
 3890func (ec *executionContext) _BugEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.BugEdge) graphql.Marshaler {
 3891	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3892	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 3893	rctx := &graphql.ResolverContext{
 3894		Object:   "BugEdge",
 3895		Field:    field,
 3896		Args:     nil,
 3897		IsMethod: false,
 3898	}
 3899	ctx = graphql.WithResolverContext(ctx, rctx)
 3900	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3901	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 3902		ctx = rctx // use context from middleware stack in children
 3903		return obj.Node, nil
 3904	})
 3905	if resTmp == nil {
 3906		if !ec.HasError(rctx) {
 3907			ec.Errorf(ctx, "must not be null")
 3908		}
 3909		return graphql.Null
 3910	}
 3911	res := resTmp.(*bug.Snapshot)
 3912	rctx.Result = res
 3913	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3914	return ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
 3915}
 3916
 3917func (ec *executionContext) _ChangeLabelPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) graphql.Marshaler {
 3918	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3919	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 3920	rctx := &graphql.ResolverContext{
 3921		Object:   "ChangeLabelPayload",
 3922		Field:    field,
 3923		Args:     nil,
 3924		IsMethod: false,
 3925	}
 3926	ctx = graphql.WithResolverContext(ctx, rctx)
 3927	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3928	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 3929		ctx = rctx // use context from middleware stack in children
 3930		return obj.ClientMutationID, nil
 3931	})
 3932	if resTmp == nil {
 3933		return graphql.Null
 3934	}
 3935	res := resTmp.(*string)
 3936	rctx.Result = res
 3937	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3938	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 3939}
 3940
 3941func (ec *executionContext) _ChangeLabelPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) graphql.Marshaler {
 3942	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3943	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 3944	rctx := &graphql.ResolverContext{
 3945		Object:   "ChangeLabelPayload",
 3946		Field:    field,
 3947		Args:     nil,
 3948		IsMethod: false,
 3949	}
 3950	ctx = graphql.WithResolverContext(ctx, rctx)
 3951	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3952	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 3953		ctx = rctx // use context from middleware stack in children
 3954		return obj.Bug, nil
 3955	})
 3956	if resTmp == nil {
 3957		if !ec.HasError(rctx) {
 3958			ec.Errorf(ctx, "must not be null")
 3959		}
 3960		return graphql.Null
 3961	}
 3962	res := resTmp.(*bug.Snapshot)
 3963	rctx.Result = res
 3964	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3965	return ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
 3966}
 3967
 3968func (ec *executionContext) _ChangeLabelPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) graphql.Marshaler {
 3969	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3970	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 3971	rctx := &graphql.ResolverContext{
 3972		Object:   "ChangeLabelPayload",
 3973		Field:    field,
 3974		Args:     nil,
 3975		IsMethod: false,
 3976	}
 3977	ctx = graphql.WithResolverContext(ctx, rctx)
 3978	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 3979	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 3980		ctx = rctx // use context from middleware stack in children
 3981		return obj.Operation, nil
 3982	})
 3983	if resTmp == nil {
 3984		if !ec.HasError(rctx) {
 3985			ec.Errorf(ctx, "must not be null")
 3986		}
 3987		return graphql.Null
 3988	}
 3989	res := resTmp.(*bug.LabelChangeOperation)
 3990	rctx.Result = res
 3991	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 3992	return ec.marshalNLabelChangeOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeOperation(ctx, field.Selections, res)
 3993}
 3994
 3995func (ec *executionContext) _ChangeLabelPayload_results(ctx context.Context, field graphql.CollectedField, obj *models.ChangeLabelPayload) graphql.Marshaler {
 3996	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 3997	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 3998	rctx := &graphql.ResolverContext{
 3999		Object:   "ChangeLabelPayload",
 4000		Field:    field,
 4001		Args:     nil,
 4002		IsMethod: false,
 4003	}
 4004	ctx = graphql.WithResolverContext(ctx, rctx)
 4005	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4006	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 4007		ctx = rctx // use context from middleware stack in children
 4008		return obj.Results, nil
 4009	})
 4010	if resTmp == nil {
 4011		if !ec.HasError(rctx) {
 4012			ec.Errorf(ctx, "must not be null")
 4013		}
 4014		return graphql.Null
 4015	}
 4016	res := resTmp.([]*bug.LabelChangeResult)
 4017	rctx.Result = res
 4018	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4019	return ec.marshalNLabelChangeResult2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx, field.Selections, res)
 4020}
 4021
 4022func (ec *executionContext) _CloseBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) graphql.Marshaler {
 4023	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4024	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 4025	rctx := &graphql.ResolverContext{
 4026		Object:   "CloseBugPayload",
 4027		Field:    field,
 4028		Args:     nil,
 4029		IsMethod: false,
 4030	}
 4031	ctx = graphql.WithResolverContext(ctx, rctx)
 4032	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4033	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 4034		ctx = rctx // use context from middleware stack in children
 4035		return obj.ClientMutationID, nil
 4036	})
 4037	if resTmp == nil {
 4038		return graphql.Null
 4039	}
 4040	res := resTmp.(*string)
 4041	rctx.Result = res
 4042	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4043	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 4044}
 4045
 4046func (ec *executionContext) _CloseBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) graphql.Marshaler {
 4047	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4048	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 4049	rctx := &graphql.ResolverContext{
 4050		Object:   "CloseBugPayload",
 4051		Field:    field,
 4052		Args:     nil,
 4053		IsMethod: false,
 4054	}
 4055	ctx = graphql.WithResolverContext(ctx, rctx)
 4056	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4057	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 4058		ctx = rctx // use context from middleware stack in children
 4059		return obj.Bug, nil
 4060	})
 4061	if resTmp == nil {
 4062		if !ec.HasError(rctx) {
 4063			ec.Errorf(ctx, "must not be null")
 4064		}
 4065		return graphql.Null
 4066	}
 4067	res := resTmp.(*bug.Snapshot)
 4068	rctx.Result = res
 4069	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4070	return ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
 4071}
 4072
 4073func (ec *executionContext) _CloseBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.CloseBugPayload) graphql.Marshaler {
 4074	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4075	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 4076	rctx := &graphql.ResolverContext{
 4077		Object:   "CloseBugPayload",
 4078		Field:    field,
 4079		Args:     nil,
 4080		IsMethod: false,
 4081	}
 4082	ctx = graphql.WithResolverContext(ctx, rctx)
 4083	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4084	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 4085		ctx = rctx // use context from middleware stack in children
 4086		return obj.Operation, nil
 4087	})
 4088	if resTmp == nil {
 4089		if !ec.HasError(rctx) {
 4090			ec.Errorf(ctx, "must not be null")
 4091		}
 4092		return graphql.Null
 4093	}
 4094	res := resTmp.(*bug.SetStatusOperation)
 4095	rctx.Result = res
 4096	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4097	return ec.marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
 4098}
 4099
 4100func (ec *executionContext) _Color_R(ctx context.Context, field graphql.CollectedField, obj *color.RGBA) graphql.Marshaler {
 4101	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4102	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 4103	rctx := &graphql.ResolverContext{
 4104		Object:   "Color",
 4105		Field:    field,
 4106		Args:     nil,
 4107		IsMethod: true,
 4108	}
 4109	ctx = graphql.WithResolverContext(ctx, rctx)
 4110	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4111	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 4112		ctx = rctx // use context from middleware stack in children
 4113		return ec.resolvers.Color().R(rctx, obj)
 4114	})
 4115	if resTmp == nil {
 4116		if !ec.HasError(rctx) {
 4117			ec.Errorf(ctx, "must not be null")
 4118		}
 4119		return graphql.Null
 4120	}
 4121	res := resTmp.(int)
 4122	rctx.Result = res
 4123	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4124	return ec.marshalNInt2int(ctx, field.Selections, res)
 4125}
 4126
 4127func (ec *executionContext) _Color_G(ctx context.Context, field graphql.CollectedField, obj *color.RGBA) graphql.Marshaler {
 4128	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4129	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 4130	rctx := &graphql.ResolverContext{
 4131		Object:   "Color",
 4132		Field:    field,
 4133		Args:     nil,
 4134		IsMethod: true,
 4135	}
 4136	ctx = graphql.WithResolverContext(ctx, rctx)
 4137	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4138	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 4139		ctx = rctx // use context from middleware stack in children
 4140		return ec.resolvers.Color().G(rctx, obj)
 4141	})
 4142	if resTmp == nil {
 4143		if !ec.HasError(rctx) {
 4144			ec.Errorf(ctx, "must not be null")
 4145		}
 4146		return graphql.Null
 4147	}
 4148	res := resTmp.(int)
 4149	rctx.Result = res
 4150	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4151	return ec.marshalNInt2int(ctx, field.Selections, res)
 4152}
 4153
 4154func (ec *executionContext) _Color_B(ctx context.Context, field graphql.CollectedField, obj *color.RGBA) graphql.Marshaler {
 4155	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4156	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 4157	rctx := &graphql.ResolverContext{
 4158		Object:   "Color",
 4159		Field:    field,
 4160		Args:     nil,
 4161		IsMethod: true,
 4162	}
 4163	ctx = graphql.WithResolverContext(ctx, rctx)
 4164	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4165	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 4166		ctx = rctx // use context from middleware stack in children
 4167		return ec.resolvers.Color().B(rctx, obj)
 4168	})
 4169	if resTmp == nil {
 4170		if !ec.HasError(rctx) {
 4171			ec.Errorf(ctx, "must not be null")
 4172		}
 4173		return graphql.Null
 4174	}
 4175	res := resTmp.(int)
 4176	rctx.Result = res
 4177	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4178	return ec.marshalNInt2int(ctx, field.Selections, res)
 4179}
 4180
 4181func (ec *executionContext) _Comment_author(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) graphql.Marshaler {
 4182	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4183	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 4184	rctx := &graphql.ResolverContext{
 4185		Object:   "Comment",
 4186		Field:    field,
 4187		Args:     nil,
 4188		IsMethod: false,
 4189	}
 4190	ctx = graphql.WithResolverContext(ctx, rctx)
 4191	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4192	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 4193		ctx = rctx // use context from middleware stack in children
 4194		return obj.Author, nil
 4195	})
 4196	if resTmp == nil {
 4197		if !ec.HasError(rctx) {
 4198			ec.Errorf(ctx, "must not be null")
 4199		}
 4200		return graphql.Null
 4201	}
 4202	res := resTmp.(identity.Interface)
 4203	rctx.Result = res
 4204	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4205	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
 4206}
 4207
 4208func (ec *executionContext) _Comment_message(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) graphql.Marshaler {
 4209	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4210	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 4211	rctx := &graphql.ResolverContext{
 4212		Object:   "Comment",
 4213		Field:    field,
 4214		Args:     nil,
 4215		IsMethod: false,
 4216	}
 4217	ctx = graphql.WithResolverContext(ctx, rctx)
 4218	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4219	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 4220		ctx = rctx // use context from middleware stack in children
 4221		return obj.Message, nil
 4222	})
 4223	if resTmp == nil {
 4224		if !ec.HasError(rctx) {
 4225			ec.Errorf(ctx, "must not be null")
 4226		}
 4227		return graphql.Null
 4228	}
 4229	res := resTmp.(string)
 4230	rctx.Result = res
 4231	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4232	return ec.marshalNString2string(ctx, field.Selections, res)
 4233}
 4234
 4235func (ec *executionContext) _Comment_files(ctx context.Context, field graphql.CollectedField, obj *bug.Comment) graphql.Marshaler {
 4236	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4237	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 4238	rctx := &graphql.ResolverContext{
 4239		Object:   "Comment",
 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 := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 4247		ctx = rctx // use context from middleware stack in children
 4248		return obj.Files, nil
 4249	})
 4250	if resTmp == nil {
 4251		if !ec.HasError(rctx) {
 4252			ec.Errorf(ctx, "must not be null")
 4253		}
 4254		return graphql.Null
 4255	}
 4256	res := resTmp.([]git.Hash)
 4257	rctx.Result = res
 4258	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4259	return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
 4260}
 4261
 4262func (ec *executionContext) _CommentConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) graphql.Marshaler {
 4263	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4264	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 4265	rctx := &graphql.ResolverContext{
 4266		Object:   "CommentConnection",
 4267		Field:    field,
 4268		Args:     nil,
 4269		IsMethod: false,
 4270	}
 4271	ctx = graphql.WithResolverContext(ctx, rctx)
 4272	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4273	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 4274		ctx = rctx // use context from middleware stack in children
 4275		return obj.Edges, nil
 4276	})
 4277	if resTmp == nil {
 4278		if !ec.HasError(rctx) {
 4279			ec.Errorf(ctx, "must not be null")
 4280		}
 4281		return graphql.Null
 4282	}
 4283	res := resTmp.([]*models.CommentEdge)
 4284	rctx.Result = res
 4285	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4286	return ec.marshalNCommentEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx, field.Selections, res)
 4287}
 4288
 4289func (ec *executionContext) _CommentConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) graphql.Marshaler {
 4290	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4291	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 4292	rctx := &graphql.ResolverContext{
 4293		Object:   "CommentConnection",
 4294		Field:    field,
 4295		Args:     nil,
 4296		IsMethod: false,
 4297	}
 4298	ctx = graphql.WithResolverContext(ctx, rctx)
 4299	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4300	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 4301		ctx = rctx // use context from middleware stack in children
 4302		return obj.Nodes, nil
 4303	})
 4304	if resTmp == nil {
 4305		if !ec.HasError(rctx) {
 4306			ec.Errorf(ctx, "must not be null")
 4307		}
 4308		return graphql.Null
 4309	}
 4310	res := resTmp.([]*bug.Comment)
 4311	rctx.Result = res
 4312	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4313	return ec.marshalNComment2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx, field.Selections, res)
 4314}
 4315
 4316func (ec *executionContext) _CommentConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) graphql.Marshaler {
 4317	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4318	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 4319	rctx := &graphql.ResolverContext{
 4320		Object:   "CommentConnection",
 4321		Field:    field,
 4322		Args:     nil,
 4323		IsMethod: false,
 4324	}
 4325	ctx = graphql.WithResolverContext(ctx, rctx)
 4326	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4327	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 4328		ctx = rctx // use context from middleware stack in children
 4329		return obj.PageInfo, nil
 4330	})
 4331	if resTmp == nil {
 4332		if !ec.HasError(rctx) {
 4333			ec.Errorf(ctx, "must not be null")
 4334		}
 4335		return graphql.Null
 4336	}
 4337	res := resTmp.(*models.PageInfo)
 4338	rctx.Result = res
 4339	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4340	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
 4341}
 4342
 4343func (ec *executionContext) _CommentConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.CommentConnection) graphql.Marshaler {
 4344	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4345	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 4346	rctx := &graphql.ResolverContext{
 4347		Object:   "CommentConnection",
 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 := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 4355		ctx = rctx // use context from middleware stack in children
 4356		return obj.TotalCount, nil
 4357	})
 4358	if resTmp == nil {
 4359		if !ec.HasError(rctx) {
 4360			ec.Errorf(ctx, "must not be null")
 4361		}
 4362		return graphql.Null
 4363	}
 4364	res := resTmp.(int)
 4365	rctx.Result = res
 4366	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4367	return ec.marshalNInt2int(ctx, field.Selections, res)
 4368}
 4369
 4370func (ec *executionContext) _CommentEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.CommentEdge) graphql.Marshaler {
 4371	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4372	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 4373	rctx := &graphql.ResolverContext{
 4374		Object:   "CommentEdge",
 4375		Field:    field,
 4376		Args:     nil,
 4377		IsMethod: false,
 4378	}
 4379	ctx = graphql.WithResolverContext(ctx, rctx)
 4380	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4381	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 4382		ctx = rctx // use context from middleware stack in children
 4383		return obj.Cursor, nil
 4384	})
 4385	if resTmp == nil {
 4386		if !ec.HasError(rctx) {
 4387			ec.Errorf(ctx, "must not be null")
 4388		}
 4389		return graphql.Null
 4390	}
 4391	res := resTmp.(string)
 4392	rctx.Result = res
 4393	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4394	return ec.marshalNString2string(ctx, field.Selections, res)
 4395}
 4396
 4397func (ec *executionContext) _CommentEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.CommentEdge) graphql.Marshaler {
 4398	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4399	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 4400	rctx := &graphql.ResolverContext{
 4401		Object:   "CommentEdge",
 4402		Field:    field,
 4403		Args:     nil,
 4404		IsMethod: false,
 4405	}
 4406	ctx = graphql.WithResolverContext(ctx, rctx)
 4407	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4408	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 4409		ctx = rctx // use context from middleware stack in children
 4410		return obj.Node, nil
 4411	})
 4412	if resTmp == nil {
 4413		if !ec.HasError(rctx) {
 4414			ec.Errorf(ctx, "must not be null")
 4415		}
 4416		return graphql.Null
 4417	}
 4418	res := resTmp.(*bug.Comment)
 4419	rctx.Result = res
 4420	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4421	return ec.marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx, field.Selections, res)
 4422}
 4423
 4424func (ec *executionContext) _CommentHistoryStep_message(ctx context.Context, field graphql.CollectedField, obj *bug.CommentHistoryStep) graphql.Marshaler {
 4425	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4426	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 4427	rctx := &graphql.ResolverContext{
 4428		Object:   "CommentHistoryStep",
 4429		Field:    field,
 4430		Args:     nil,
 4431		IsMethod: false,
 4432	}
 4433	ctx = graphql.WithResolverContext(ctx, rctx)
 4434	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4435	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 4436		ctx = rctx // use context from middleware stack in children
 4437		return obj.Message, nil
 4438	})
 4439	if resTmp == nil {
 4440		if !ec.HasError(rctx) {
 4441			ec.Errorf(ctx, "must not be null")
 4442		}
 4443		return graphql.Null
 4444	}
 4445	res := resTmp.(string)
 4446	rctx.Result = res
 4447	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4448	return ec.marshalNString2string(ctx, field.Selections, res)
 4449}
 4450
 4451func (ec *executionContext) _CommentHistoryStep_date(ctx context.Context, field graphql.CollectedField, obj *bug.CommentHistoryStep) graphql.Marshaler {
 4452	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4453	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 4454	rctx := &graphql.ResolverContext{
 4455		Object:   "CommentHistoryStep",
 4456		Field:    field,
 4457		Args:     nil,
 4458		IsMethod: true,
 4459	}
 4460	ctx = graphql.WithResolverContext(ctx, rctx)
 4461	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4462	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 4463		ctx = rctx // use context from middleware stack in children
 4464		return ec.resolvers.CommentHistoryStep().Date(rctx, obj)
 4465	})
 4466	if resTmp == nil {
 4467		if !ec.HasError(rctx) {
 4468			ec.Errorf(ctx, "must not be null")
 4469		}
 4470		return graphql.Null
 4471	}
 4472	res := resTmp.(*time.Time)
 4473	rctx.Result = res
 4474	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4475	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 4476}
 4477
 4478func (ec *executionContext) _CommitAsNeededPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.CommitAsNeededPayload) graphql.Marshaler {
 4479	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4480	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 4481	rctx := &graphql.ResolverContext{
 4482		Object:   "CommitAsNeededPayload",
 4483		Field:    field,
 4484		Args:     nil,
 4485		IsMethod: false,
 4486	}
 4487	ctx = graphql.WithResolverContext(ctx, rctx)
 4488	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4489	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 4490		ctx = rctx // use context from middleware stack in children
 4491		return obj.ClientMutationID, nil
 4492	})
 4493	if resTmp == nil {
 4494		return graphql.Null
 4495	}
 4496	res := resTmp.(*string)
 4497	rctx.Result = res
 4498	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4499	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 4500}
 4501
 4502func (ec *executionContext) _CommitAsNeededPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.CommitAsNeededPayload) graphql.Marshaler {
 4503	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4504	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 4505	rctx := &graphql.ResolverContext{
 4506		Object:   "CommitAsNeededPayload",
 4507		Field:    field,
 4508		Args:     nil,
 4509		IsMethod: false,
 4510	}
 4511	ctx = graphql.WithResolverContext(ctx, rctx)
 4512	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4513	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 4514		ctx = rctx // use context from middleware stack in children
 4515		return obj.Bug, nil
 4516	})
 4517	if resTmp == nil {
 4518		if !ec.HasError(rctx) {
 4519			ec.Errorf(ctx, "must not be null")
 4520		}
 4521		return graphql.Null
 4522	}
 4523	res := resTmp.(*bug.Snapshot)
 4524	rctx.Result = res
 4525	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4526	return ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
 4527}
 4528
 4529func (ec *executionContext) _CommitPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.CommitPayload) graphql.Marshaler {
 4530	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4531	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 4532	rctx := &graphql.ResolverContext{
 4533		Object:   "CommitPayload",
 4534		Field:    field,
 4535		Args:     nil,
 4536		IsMethod: false,
 4537	}
 4538	ctx = graphql.WithResolverContext(ctx, rctx)
 4539	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4540	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 4541		ctx = rctx // use context from middleware stack in children
 4542		return obj.ClientMutationID, nil
 4543	})
 4544	if resTmp == nil {
 4545		return graphql.Null
 4546	}
 4547	res := resTmp.(*string)
 4548	rctx.Result = res
 4549	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4550	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 4551}
 4552
 4553func (ec *executionContext) _CommitPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.CommitPayload) graphql.Marshaler {
 4554	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4555	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 4556	rctx := &graphql.ResolverContext{
 4557		Object:   "CommitPayload",
 4558		Field:    field,
 4559		Args:     nil,
 4560		IsMethod: false,
 4561	}
 4562	ctx = graphql.WithResolverContext(ctx, rctx)
 4563	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4564	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 4565		ctx = rctx // use context from middleware stack in children
 4566		return obj.Bug, nil
 4567	})
 4568	if resTmp == nil {
 4569		if !ec.HasError(rctx) {
 4570			ec.Errorf(ctx, "must not be null")
 4571		}
 4572		return graphql.Null
 4573	}
 4574	res := resTmp.(*bug.Snapshot)
 4575	rctx.Result = res
 4576	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4577	return ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
 4578}
 4579
 4580func (ec *executionContext) _CreateOperation_hash(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) graphql.Marshaler {
 4581	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4582	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 4583	rctx := &graphql.ResolverContext{
 4584		Object:   "CreateOperation",
 4585		Field:    field,
 4586		Args:     nil,
 4587		IsMethod: true,
 4588	}
 4589	ctx = graphql.WithResolverContext(ctx, rctx)
 4590	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4591	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 4592		ctx = rctx // use context from middleware stack in children
 4593		return obj.Hash()
 4594	})
 4595	if resTmp == nil {
 4596		if !ec.HasError(rctx) {
 4597			ec.Errorf(ctx, "must not be null")
 4598		}
 4599		return graphql.Null
 4600	}
 4601	res := resTmp.(git.Hash)
 4602	rctx.Result = res
 4603	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4604	return ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
 4605}
 4606
 4607func (ec *executionContext) _CreateOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) graphql.Marshaler {
 4608	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4609	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 4610	rctx := &graphql.ResolverContext{
 4611		Object:   "CreateOperation",
 4612		Field:    field,
 4613		Args:     nil,
 4614		IsMethod: false,
 4615	}
 4616	ctx = graphql.WithResolverContext(ctx, rctx)
 4617	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4618	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 4619		ctx = rctx // use context from middleware stack in children
 4620		return obj.Author, nil
 4621	})
 4622	if resTmp == nil {
 4623		if !ec.HasError(rctx) {
 4624			ec.Errorf(ctx, "must not be null")
 4625		}
 4626		return graphql.Null
 4627	}
 4628	res := resTmp.(identity.Interface)
 4629	rctx.Result = res
 4630	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4631	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
 4632}
 4633
 4634func (ec *executionContext) _CreateOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) graphql.Marshaler {
 4635	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4636	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 4637	rctx := &graphql.ResolverContext{
 4638		Object:   "CreateOperation",
 4639		Field:    field,
 4640		Args:     nil,
 4641		IsMethod: true,
 4642	}
 4643	ctx = graphql.WithResolverContext(ctx, rctx)
 4644	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4645	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 4646		ctx = rctx // use context from middleware stack in children
 4647		return ec.resolvers.CreateOperation().Date(rctx, obj)
 4648	})
 4649	if resTmp == nil {
 4650		if !ec.HasError(rctx) {
 4651			ec.Errorf(ctx, "must not be null")
 4652		}
 4653		return graphql.Null
 4654	}
 4655	res := resTmp.(*time.Time)
 4656	rctx.Result = res
 4657	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4658	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 4659}
 4660
 4661func (ec *executionContext) _CreateOperation_title(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) graphql.Marshaler {
 4662	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4663	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 4664	rctx := &graphql.ResolverContext{
 4665		Object:   "CreateOperation",
 4666		Field:    field,
 4667		Args:     nil,
 4668		IsMethod: false,
 4669	}
 4670	ctx = graphql.WithResolverContext(ctx, rctx)
 4671	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4672	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 4673		ctx = rctx // use context from middleware stack in children
 4674		return obj.Title, nil
 4675	})
 4676	if resTmp == nil {
 4677		if !ec.HasError(rctx) {
 4678			ec.Errorf(ctx, "must not be null")
 4679		}
 4680		return graphql.Null
 4681	}
 4682	res := resTmp.(string)
 4683	rctx.Result = res
 4684	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4685	return ec.marshalNString2string(ctx, field.Selections, res)
 4686}
 4687
 4688func (ec *executionContext) _CreateOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) graphql.Marshaler {
 4689	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4690	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 4691	rctx := &graphql.ResolverContext{
 4692		Object:   "CreateOperation",
 4693		Field:    field,
 4694		Args:     nil,
 4695		IsMethod: false,
 4696	}
 4697	ctx = graphql.WithResolverContext(ctx, rctx)
 4698	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4699	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 4700		ctx = rctx // use context from middleware stack in children
 4701		return obj.Message, nil
 4702	})
 4703	if resTmp == nil {
 4704		if !ec.HasError(rctx) {
 4705			ec.Errorf(ctx, "must not be null")
 4706		}
 4707		return graphql.Null
 4708	}
 4709	res := resTmp.(string)
 4710	rctx.Result = res
 4711	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4712	return ec.marshalNString2string(ctx, field.Selections, res)
 4713}
 4714
 4715func (ec *executionContext) _CreateOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.CreateOperation) graphql.Marshaler {
 4716	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4717	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 4718	rctx := &graphql.ResolverContext{
 4719		Object:   "CreateOperation",
 4720		Field:    field,
 4721		Args:     nil,
 4722		IsMethod: false,
 4723	}
 4724	ctx = graphql.WithResolverContext(ctx, rctx)
 4725	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4726	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 4727		ctx = rctx // use context from middleware stack in children
 4728		return obj.Files, nil
 4729	})
 4730	if resTmp == nil {
 4731		if !ec.HasError(rctx) {
 4732			ec.Errorf(ctx, "must not be null")
 4733		}
 4734		return graphql.Null
 4735	}
 4736	res := resTmp.([]git.Hash)
 4737	rctx.Result = res
 4738	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4739	return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
 4740}
 4741
 4742func (ec *executionContext) _CreateTimelineItem_hash(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) graphql.Marshaler {
 4743	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4744	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 4745	rctx := &graphql.ResolverContext{
 4746		Object:   "CreateTimelineItem",
 4747		Field:    field,
 4748		Args:     nil,
 4749		IsMethod: true,
 4750	}
 4751	ctx = graphql.WithResolverContext(ctx, rctx)
 4752	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4753	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 4754		ctx = rctx // use context from middleware stack in children
 4755		return obj.Hash(), nil
 4756	})
 4757	if resTmp == nil {
 4758		if !ec.HasError(rctx) {
 4759			ec.Errorf(ctx, "must not be null")
 4760		}
 4761		return graphql.Null
 4762	}
 4763	res := resTmp.(git.Hash)
 4764	rctx.Result = res
 4765	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4766	return ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
 4767}
 4768
 4769func (ec *executionContext) _CreateTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) graphql.Marshaler {
 4770	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4771	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 4772	rctx := &graphql.ResolverContext{
 4773		Object:   "CreateTimelineItem",
 4774		Field:    field,
 4775		Args:     nil,
 4776		IsMethod: false,
 4777	}
 4778	ctx = graphql.WithResolverContext(ctx, rctx)
 4779	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4780	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 4781		ctx = rctx // use context from middleware stack in children
 4782		return obj.Author, nil
 4783	})
 4784	if resTmp == nil {
 4785		if !ec.HasError(rctx) {
 4786			ec.Errorf(ctx, "must not be null")
 4787		}
 4788		return graphql.Null
 4789	}
 4790	res := resTmp.(identity.Interface)
 4791	rctx.Result = res
 4792	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4793	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
 4794}
 4795
 4796func (ec *executionContext) _CreateTimelineItem_message(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) graphql.Marshaler {
 4797	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4798	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 4799	rctx := &graphql.ResolverContext{
 4800		Object:   "CreateTimelineItem",
 4801		Field:    field,
 4802		Args:     nil,
 4803		IsMethod: false,
 4804	}
 4805	ctx = graphql.WithResolverContext(ctx, rctx)
 4806	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4807	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 4808		ctx = rctx // use context from middleware stack in children
 4809		return obj.Message, nil
 4810	})
 4811	if resTmp == nil {
 4812		if !ec.HasError(rctx) {
 4813			ec.Errorf(ctx, "must not be null")
 4814		}
 4815		return graphql.Null
 4816	}
 4817	res := resTmp.(string)
 4818	rctx.Result = res
 4819	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4820	return ec.marshalNString2string(ctx, field.Selections, res)
 4821}
 4822
 4823func (ec *executionContext) _CreateTimelineItem_messageIsEmpty(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) graphql.Marshaler {
 4824	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4825	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 4826	rctx := &graphql.ResolverContext{
 4827		Object:   "CreateTimelineItem",
 4828		Field:    field,
 4829		Args:     nil,
 4830		IsMethod: true,
 4831	}
 4832	ctx = graphql.WithResolverContext(ctx, rctx)
 4833	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4834	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 4835		ctx = rctx // use context from middleware stack in children
 4836		return obj.MessageIsEmpty(), nil
 4837	})
 4838	if resTmp == nil {
 4839		if !ec.HasError(rctx) {
 4840			ec.Errorf(ctx, "must not be null")
 4841		}
 4842		return graphql.Null
 4843	}
 4844	res := resTmp.(bool)
 4845	rctx.Result = res
 4846	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4847	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 4848}
 4849
 4850func (ec *executionContext) _CreateTimelineItem_files(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) graphql.Marshaler {
 4851	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4852	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 4853	rctx := &graphql.ResolverContext{
 4854		Object:   "CreateTimelineItem",
 4855		Field:    field,
 4856		Args:     nil,
 4857		IsMethod: false,
 4858	}
 4859	ctx = graphql.WithResolverContext(ctx, rctx)
 4860	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4861	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 4862		ctx = rctx // use context from middleware stack in children
 4863		return obj.Files, nil
 4864	})
 4865	if resTmp == nil {
 4866		if !ec.HasError(rctx) {
 4867			ec.Errorf(ctx, "must not be null")
 4868		}
 4869		return graphql.Null
 4870	}
 4871	res := resTmp.([]git.Hash)
 4872	rctx.Result = res
 4873	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4874	return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
 4875}
 4876
 4877func (ec *executionContext) _CreateTimelineItem_createdAt(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) graphql.Marshaler {
 4878	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4879	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 4880	rctx := &graphql.ResolverContext{
 4881		Object:   "CreateTimelineItem",
 4882		Field:    field,
 4883		Args:     nil,
 4884		IsMethod: true,
 4885	}
 4886	ctx = graphql.WithResolverContext(ctx, rctx)
 4887	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4888	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 4889		ctx = rctx // use context from middleware stack in children
 4890		return ec.resolvers.CreateTimelineItem().CreatedAt(rctx, obj)
 4891	})
 4892	if resTmp == nil {
 4893		if !ec.HasError(rctx) {
 4894			ec.Errorf(ctx, "must not be null")
 4895		}
 4896		return graphql.Null
 4897	}
 4898	res := resTmp.(*time.Time)
 4899	rctx.Result = res
 4900	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4901	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 4902}
 4903
 4904func (ec *executionContext) _CreateTimelineItem_lastEdit(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) graphql.Marshaler {
 4905	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4906	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 4907	rctx := &graphql.ResolverContext{
 4908		Object:   "CreateTimelineItem",
 4909		Field:    field,
 4910		Args:     nil,
 4911		IsMethod: true,
 4912	}
 4913	ctx = graphql.WithResolverContext(ctx, rctx)
 4914	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4915	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 4916		ctx = rctx // use context from middleware stack in children
 4917		return ec.resolvers.CreateTimelineItem().LastEdit(rctx, obj)
 4918	})
 4919	if resTmp == nil {
 4920		if !ec.HasError(rctx) {
 4921			ec.Errorf(ctx, "must not be null")
 4922		}
 4923		return graphql.Null
 4924	}
 4925	res := resTmp.(*time.Time)
 4926	rctx.Result = res
 4927	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4928	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 4929}
 4930
 4931func (ec *executionContext) _CreateTimelineItem_edited(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) graphql.Marshaler {
 4932	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4933	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 4934	rctx := &graphql.ResolverContext{
 4935		Object:   "CreateTimelineItem",
 4936		Field:    field,
 4937		Args:     nil,
 4938		IsMethod: true,
 4939	}
 4940	ctx = graphql.WithResolverContext(ctx, rctx)
 4941	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4942	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 4943		ctx = rctx // use context from middleware stack in children
 4944		return obj.Edited(), nil
 4945	})
 4946	if resTmp == nil {
 4947		if !ec.HasError(rctx) {
 4948			ec.Errorf(ctx, "must not be null")
 4949		}
 4950		return graphql.Null
 4951	}
 4952	res := resTmp.(bool)
 4953	rctx.Result = res
 4954	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4955	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 4956}
 4957
 4958func (ec *executionContext) _CreateTimelineItem_history(ctx context.Context, field graphql.CollectedField, obj *bug.CreateTimelineItem) graphql.Marshaler {
 4959	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4960	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 4961	rctx := &graphql.ResolverContext{
 4962		Object:   "CreateTimelineItem",
 4963		Field:    field,
 4964		Args:     nil,
 4965		IsMethod: false,
 4966	}
 4967	ctx = graphql.WithResolverContext(ctx, rctx)
 4968	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4969	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 4970		ctx = rctx // use context from middleware stack in children
 4971		return obj.History, nil
 4972	})
 4973	if resTmp == nil {
 4974		if !ec.HasError(rctx) {
 4975			ec.Errorf(ctx, "must not be null")
 4976		}
 4977		return graphql.Null
 4978	}
 4979	res := resTmp.([]bug.CommentHistoryStep)
 4980	rctx.Result = res
 4981	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 4982	return ec.marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx, field.Selections, res)
 4983}
 4984
 4985func (ec *executionContext) _EditCommentOperation_hash(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) graphql.Marshaler {
 4986	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 4987	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 4988	rctx := &graphql.ResolverContext{
 4989		Object:   "EditCommentOperation",
 4990		Field:    field,
 4991		Args:     nil,
 4992		IsMethod: true,
 4993	}
 4994	ctx = graphql.WithResolverContext(ctx, rctx)
 4995	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 4996	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 4997		ctx = rctx // use context from middleware stack in children
 4998		return obj.Hash()
 4999	})
 5000	if resTmp == nil {
 5001		if !ec.HasError(rctx) {
 5002			ec.Errorf(ctx, "must not be null")
 5003		}
 5004		return graphql.Null
 5005	}
 5006	res := resTmp.(git.Hash)
 5007	rctx.Result = res
 5008	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5009	return ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
 5010}
 5011
 5012func (ec *executionContext) _EditCommentOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) graphql.Marshaler {
 5013	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5014	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 5015	rctx := &graphql.ResolverContext{
 5016		Object:   "EditCommentOperation",
 5017		Field:    field,
 5018		Args:     nil,
 5019		IsMethod: false,
 5020	}
 5021	ctx = graphql.WithResolverContext(ctx, rctx)
 5022	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5023	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 5024		ctx = rctx // use context from middleware stack in children
 5025		return obj.Author, nil
 5026	})
 5027	if resTmp == nil {
 5028		if !ec.HasError(rctx) {
 5029			ec.Errorf(ctx, "must not be null")
 5030		}
 5031		return graphql.Null
 5032	}
 5033	res := resTmp.(identity.Interface)
 5034	rctx.Result = res
 5035	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5036	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
 5037}
 5038
 5039func (ec *executionContext) _EditCommentOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) graphql.Marshaler {
 5040	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5041	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 5042	rctx := &graphql.ResolverContext{
 5043		Object:   "EditCommentOperation",
 5044		Field:    field,
 5045		Args:     nil,
 5046		IsMethod: true,
 5047	}
 5048	ctx = graphql.WithResolverContext(ctx, rctx)
 5049	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5050	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 5051		ctx = rctx // use context from middleware stack in children
 5052		return ec.resolvers.EditCommentOperation().Date(rctx, obj)
 5053	})
 5054	if resTmp == nil {
 5055		if !ec.HasError(rctx) {
 5056			ec.Errorf(ctx, "must not be null")
 5057		}
 5058		return graphql.Null
 5059	}
 5060	res := resTmp.(*time.Time)
 5061	rctx.Result = res
 5062	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5063	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 5064}
 5065
 5066func (ec *executionContext) _EditCommentOperation_target(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) graphql.Marshaler {
 5067	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5068	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 5069	rctx := &graphql.ResolverContext{
 5070		Object:   "EditCommentOperation",
 5071		Field:    field,
 5072		Args:     nil,
 5073		IsMethod: false,
 5074	}
 5075	ctx = graphql.WithResolverContext(ctx, rctx)
 5076	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5077	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 5078		ctx = rctx // use context from middleware stack in children
 5079		return obj.Target, nil
 5080	})
 5081	if resTmp == nil {
 5082		if !ec.HasError(rctx) {
 5083			ec.Errorf(ctx, "must not be null")
 5084		}
 5085		return graphql.Null
 5086	}
 5087	res := resTmp.(git.Hash)
 5088	rctx.Result = res
 5089	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5090	return ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
 5091}
 5092
 5093func (ec *executionContext) _EditCommentOperation_message(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) graphql.Marshaler {
 5094	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5095	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 5096	rctx := &graphql.ResolverContext{
 5097		Object:   "EditCommentOperation",
 5098		Field:    field,
 5099		Args:     nil,
 5100		IsMethod: false,
 5101	}
 5102	ctx = graphql.WithResolverContext(ctx, rctx)
 5103	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5104	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 5105		ctx = rctx // use context from middleware stack in children
 5106		return obj.Message, nil
 5107	})
 5108	if resTmp == nil {
 5109		if !ec.HasError(rctx) {
 5110			ec.Errorf(ctx, "must not be null")
 5111		}
 5112		return graphql.Null
 5113	}
 5114	res := resTmp.(string)
 5115	rctx.Result = res
 5116	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5117	return ec.marshalNString2string(ctx, field.Selections, res)
 5118}
 5119
 5120func (ec *executionContext) _EditCommentOperation_files(ctx context.Context, field graphql.CollectedField, obj *bug.EditCommentOperation) graphql.Marshaler {
 5121	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5122	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 5123	rctx := &graphql.ResolverContext{
 5124		Object:   "EditCommentOperation",
 5125		Field:    field,
 5126		Args:     nil,
 5127		IsMethod: false,
 5128	}
 5129	ctx = graphql.WithResolverContext(ctx, rctx)
 5130	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5131	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 5132		ctx = rctx // use context from middleware stack in children
 5133		return obj.Files, nil
 5134	})
 5135	if resTmp == nil {
 5136		if !ec.HasError(rctx) {
 5137			ec.Errorf(ctx, "must not be null")
 5138		}
 5139		return graphql.Null
 5140	}
 5141	res := resTmp.([]git.Hash)
 5142	rctx.Result = res
 5143	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5144	return ec.marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
 5145}
 5146
 5147func (ec *executionContext) _Identity_id(ctx context.Context, field graphql.CollectedField, obj *identity.Interface) graphql.Marshaler {
 5148	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5149	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 5150	rctx := &graphql.ResolverContext{
 5151		Object:   "Identity",
 5152		Field:    field,
 5153		Args:     nil,
 5154		IsMethod: true,
 5155	}
 5156	ctx = graphql.WithResolverContext(ctx, rctx)
 5157	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5158	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 5159		ctx = rctx // use context from middleware stack in children
 5160		return ec.resolvers.Identity().ID(rctx, obj)
 5161	})
 5162	if resTmp == nil {
 5163		if !ec.HasError(rctx) {
 5164			ec.Errorf(ctx, "must not be null")
 5165		}
 5166		return graphql.Null
 5167	}
 5168	res := resTmp.(string)
 5169	rctx.Result = res
 5170	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5171	return ec.marshalNString2string(ctx, field.Selections, res)
 5172}
 5173
 5174func (ec *executionContext) _Identity_humanId(ctx context.Context, field graphql.CollectedField, obj *identity.Interface) graphql.Marshaler {
 5175	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5176	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 5177	rctx := &graphql.ResolverContext{
 5178		Object:   "Identity",
 5179		Field:    field,
 5180		Args:     nil,
 5181		IsMethod: true,
 5182	}
 5183	ctx = graphql.WithResolverContext(ctx, rctx)
 5184	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5185	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 5186		ctx = rctx // use context from middleware stack in children
 5187		return ec.resolvers.Identity().HumanID(rctx, obj)
 5188	})
 5189	if resTmp == nil {
 5190		if !ec.HasError(rctx) {
 5191			ec.Errorf(ctx, "must not be null")
 5192		}
 5193		return graphql.Null
 5194	}
 5195	res := resTmp.(string)
 5196	rctx.Result = res
 5197	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5198	return ec.marshalNString2string(ctx, field.Selections, res)
 5199}
 5200
 5201func (ec *executionContext) _Identity_name(ctx context.Context, field graphql.CollectedField, obj *identity.Interface) graphql.Marshaler {
 5202	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5203	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 5204	rctx := &graphql.ResolverContext{
 5205		Object:   "Identity",
 5206		Field:    field,
 5207		Args:     nil,
 5208		IsMethod: true,
 5209	}
 5210	ctx = graphql.WithResolverContext(ctx, rctx)
 5211	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5212	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 5213		ctx = rctx // use context from middleware stack in children
 5214		return ec.resolvers.Identity().Name(rctx, obj)
 5215	})
 5216	if resTmp == nil {
 5217		return graphql.Null
 5218	}
 5219	res := resTmp.(*string)
 5220	rctx.Result = res
 5221	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5222	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 5223}
 5224
 5225func (ec *executionContext) _Identity_email(ctx context.Context, field graphql.CollectedField, obj *identity.Interface) graphql.Marshaler {
 5226	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5227	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 5228	rctx := &graphql.ResolverContext{
 5229		Object:   "Identity",
 5230		Field:    field,
 5231		Args:     nil,
 5232		IsMethod: true,
 5233	}
 5234	ctx = graphql.WithResolverContext(ctx, rctx)
 5235	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5236	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 5237		ctx = rctx // use context from middleware stack in children
 5238		return ec.resolvers.Identity().Email(rctx, obj)
 5239	})
 5240	if resTmp == nil {
 5241		return graphql.Null
 5242	}
 5243	res := resTmp.(*string)
 5244	rctx.Result = res
 5245	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5246	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 5247}
 5248
 5249func (ec *executionContext) _Identity_login(ctx context.Context, field graphql.CollectedField, obj *identity.Interface) graphql.Marshaler {
 5250	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5251	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 5252	rctx := &graphql.ResolverContext{
 5253		Object:   "Identity",
 5254		Field:    field,
 5255		Args:     nil,
 5256		IsMethod: true,
 5257	}
 5258	ctx = graphql.WithResolverContext(ctx, rctx)
 5259	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5260	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 5261		ctx = rctx // use context from middleware stack in children
 5262		return ec.resolvers.Identity().Login(rctx, obj)
 5263	})
 5264	if resTmp == nil {
 5265		return graphql.Null
 5266	}
 5267	res := resTmp.(*string)
 5268	rctx.Result = res
 5269	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5270	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 5271}
 5272
 5273func (ec *executionContext) _Identity_displayName(ctx context.Context, field graphql.CollectedField, obj *identity.Interface) graphql.Marshaler {
 5274	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5275	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 5276	rctx := &graphql.ResolverContext{
 5277		Object:   "Identity",
 5278		Field:    field,
 5279		Args:     nil,
 5280		IsMethod: true,
 5281	}
 5282	ctx = graphql.WithResolverContext(ctx, rctx)
 5283	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5284	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 5285		ctx = rctx // use context from middleware stack in children
 5286		return ec.resolvers.Identity().DisplayName(rctx, obj)
 5287	})
 5288	if resTmp == nil {
 5289		if !ec.HasError(rctx) {
 5290			ec.Errorf(ctx, "must not be null")
 5291		}
 5292		return graphql.Null
 5293	}
 5294	res := resTmp.(string)
 5295	rctx.Result = res
 5296	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5297	return ec.marshalNString2string(ctx, field.Selections, res)
 5298}
 5299
 5300func (ec *executionContext) _Identity_avatarUrl(ctx context.Context, field graphql.CollectedField, obj *identity.Interface) graphql.Marshaler {
 5301	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5302	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 5303	rctx := &graphql.ResolverContext{
 5304		Object:   "Identity",
 5305		Field:    field,
 5306		Args:     nil,
 5307		IsMethod: true,
 5308	}
 5309	ctx = graphql.WithResolverContext(ctx, rctx)
 5310	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5311	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 5312		ctx = rctx // use context from middleware stack in children
 5313		return ec.resolvers.Identity().AvatarURL(rctx, obj)
 5314	})
 5315	if resTmp == nil {
 5316		return graphql.Null
 5317	}
 5318	res := resTmp.(*string)
 5319	rctx.Result = res
 5320	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5321	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 5322}
 5323
 5324func (ec *executionContext) _Identity_isProtected(ctx context.Context, field graphql.CollectedField, obj *identity.Interface) graphql.Marshaler {
 5325	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5326	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 5327	rctx := &graphql.ResolverContext{
 5328		Object:   "Identity",
 5329		Field:    field,
 5330		Args:     nil,
 5331		IsMethod: true,
 5332	}
 5333	ctx = graphql.WithResolverContext(ctx, rctx)
 5334	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5335	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 5336		ctx = rctx // use context from middleware stack in children
 5337		return ec.resolvers.Identity().IsProtected(rctx, obj)
 5338	})
 5339	if resTmp == nil {
 5340		if !ec.HasError(rctx) {
 5341			ec.Errorf(ctx, "must not be null")
 5342		}
 5343		return graphql.Null
 5344	}
 5345	res := resTmp.(bool)
 5346	rctx.Result = res
 5347	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5348	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 5349}
 5350
 5351func (ec *executionContext) _IdentityConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) graphql.Marshaler {
 5352	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5353	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 5354	rctx := &graphql.ResolverContext{
 5355		Object:   "IdentityConnection",
 5356		Field:    field,
 5357		Args:     nil,
 5358		IsMethod: false,
 5359	}
 5360	ctx = graphql.WithResolverContext(ctx, rctx)
 5361	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5362	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 5363		ctx = rctx // use context from middleware stack in children
 5364		return obj.Edges, nil
 5365	})
 5366	if resTmp == nil {
 5367		if !ec.HasError(rctx) {
 5368			ec.Errorf(ctx, "must not be null")
 5369		}
 5370		return graphql.Null
 5371	}
 5372	res := resTmp.([]*models.IdentityEdge)
 5373	rctx.Result = res
 5374	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5375	return ec.marshalNIdentityEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx, field.Selections, res)
 5376}
 5377
 5378func (ec *executionContext) _IdentityConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) graphql.Marshaler {
 5379	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5380	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 5381	rctx := &graphql.ResolverContext{
 5382		Object:   "IdentityConnection",
 5383		Field:    field,
 5384		Args:     nil,
 5385		IsMethod: false,
 5386	}
 5387	ctx = graphql.WithResolverContext(ctx, rctx)
 5388	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5389	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 5390		ctx = rctx // use context from middleware stack in children
 5391		return obj.Nodes, nil
 5392	})
 5393	if resTmp == nil {
 5394		if !ec.HasError(rctx) {
 5395			ec.Errorf(ctx, "must not be null")
 5396		}
 5397		return graphql.Null
 5398	}
 5399	res := resTmp.([]identity.Interface)
 5400	rctx.Result = res
 5401	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5402	return ec.marshalNIdentity2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
 5403}
 5404
 5405func (ec *executionContext) _IdentityConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) graphql.Marshaler {
 5406	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5407	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 5408	rctx := &graphql.ResolverContext{
 5409		Object:   "IdentityConnection",
 5410		Field:    field,
 5411		Args:     nil,
 5412		IsMethod: false,
 5413	}
 5414	ctx = graphql.WithResolverContext(ctx, rctx)
 5415	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5416	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 5417		ctx = rctx // use context from middleware stack in children
 5418		return obj.PageInfo, nil
 5419	})
 5420	if resTmp == nil {
 5421		if !ec.HasError(rctx) {
 5422			ec.Errorf(ctx, "must not be null")
 5423		}
 5424		return graphql.Null
 5425	}
 5426	res := resTmp.(*models.PageInfo)
 5427	rctx.Result = res
 5428	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5429	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
 5430}
 5431
 5432func (ec *executionContext) _IdentityConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.IdentityConnection) graphql.Marshaler {
 5433	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5434	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 5435	rctx := &graphql.ResolverContext{
 5436		Object:   "IdentityConnection",
 5437		Field:    field,
 5438		Args:     nil,
 5439		IsMethod: false,
 5440	}
 5441	ctx = graphql.WithResolverContext(ctx, rctx)
 5442	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5443	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 5444		ctx = rctx // use context from middleware stack in children
 5445		return obj.TotalCount, nil
 5446	})
 5447	if resTmp == nil {
 5448		if !ec.HasError(rctx) {
 5449			ec.Errorf(ctx, "must not be null")
 5450		}
 5451		return graphql.Null
 5452	}
 5453	res := resTmp.(int)
 5454	rctx.Result = res
 5455	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5456	return ec.marshalNInt2int(ctx, field.Selections, res)
 5457}
 5458
 5459func (ec *executionContext) _IdentityEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.IdentityEdge) graphql.Marshaler {
 5460	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5461	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 5462	rctx := &graphql.ResolverContext{
 5463		Object:   "IdentityEdge",
 5464		Field:    field,
 5465		Args:     nil,
 5466		IsMethod: false,
 5467	}
 5468	ctx = graphql.WithResolverContext(ctx, rctx)
 5469	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5470	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 5471		ctx = rctx // use context from middleware stack in children
 5472		return obj.Cursor, nil
 5473	})
 5474	if resTmp == nil {
 5475		if !ec.HasError(rctx) {
 5476			ec.Errorf(ctx, "must not be null")
 5477		}
 5478		return graphql.Null
 5479	}
 5480	res := resTmp.(string)
 5481	rctx.Result = res
 5482	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5483	return ec.marshalNString2string(ctx, field.Selections, res)
 5484}
 5485
 5486func (ec *executionContext) _IdentityEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.IdentityEdge) graphql.Marshaler {
 5487	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5488	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 5489	rctx := &graphql.ResolverContext{
 5490		Object:   "IdentityEdge",
 5491		Field:    field,
 5492		Args:     nil,
 5493		IsMethod: false,
 5494	}
 5495	ctx = graphql.WithResolverContext(ctx, rctx)
 5496	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5497	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 5498		ctx = rctx // use context from middleware stack in children
 5499		return obj.Node, nil
 5500	})
 5501	if resTmp == nil {
 5502		if !ec.HasError(rctx) {
 5503			ec.Errorf(ctx, "must not be null")
 5504		}
 5505		return graphql.Null
 5506	}
 5507	res := resTmp.(identity.Interface)
 5508	rctx.Result = res
 5509	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5510	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
 5511}
 5512
 5513func (ec *executionContext) _Label_name(ctx context.Context, field graphql.CollectedField, obj *bug.Label) graphql.Marshaler {
 5514	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5515	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 5516	rctx := &graphql.ResolverContext{
 5517		Object:   "Label",
 5518		Field:    field,
 5519		Args:     nil,
 5520		IsMethod: true,
 5521	}
 5522	ctx = graphql.WithResolverContext(ctx, rctx)
 5523	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5524	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 5525		ctx = rctx // use context from middleware stack in children
 5526		return ec.resolvers.Label().Name(rctx, obj)
 5527	})
 5528	if resTmp == nil {
 5529		if !ec.HasError(rctx) {
 5530			ec.Errorf(ctx, "must not be null")
 5531		}
 5532		return graphql.Null
 5533	}
 5534	res := resTmp.(string)
 5535	rctx.Result = res
 5536	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5537	return ec.marshalNString2string(ctx, field.Selections, res)
 5538}
 5539
 5540func (ec *executionContext) _Label_color(ctx context.Context, field graphql.CollectedField, obj *bug.Label) graphql.Marshaler {
 5541	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5542	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 5543	rctx := &graphql.ResolverContext{
 5544		Object:   "Label",
 5545		Field:    field,
 5546		Args:     nil,
 5547		IsMethod: true,
 5548	}
 5549	ctx = graphql.WithResolverContext(ctx, rctx)
 5550	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5551	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 5552		ctx = rctx // use context from middleware stack in children
 5553		return ec.resolvers.Label().Color(rctx, obj)
 5554	})
 5555	if resTmp == nil {
 5556		if !ec.HasError(rctx) {
 5557			ec.Errorf(ctx, "must not be null")
 5558		}
 5559		return graphql.Null
 5560	}
 5561	res := resTmp.(*color.RGBA)
 5562	rctx.Result = res
 5563	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5564	return ec.marshalNColor2ᚖimageᚋcolorᚐRGBA(ctx, field.Selections, res)
 5565}
 5566
 5567func (ec *executionContext) _LabelChangeOperation_hash(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) graphql.Marshaler {
 5568	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5569	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 5570	rctx := &graphql.ResolverContext{
 5571		Object:   "LabelChangeOperation",
 5572		Field:    field,
 5573		Args:     nil,
 5574		IsMethod: true,
 5575	}
 5576	ctx = graphql.WithResolverContext(ctx, rctx)
 5577	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5578	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 5579		ctx = rctx // use context from middleware stack in children
 5580		return obj.Hash()
 5581	})
 5582	if resTmp == nil {
 5583		if !ec.HasError(rctx) {
 5584			ec.Errorf(ctx, "must not be null")
 5585		}
 5586		return graphql.Null
 5587	}
 5588	res := resTmp.(git.Hash)
 5589	rctx.Result = res
 5590	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5591	return ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
 5592}
 5593
 5594func (ec *executionContext) _LabelChangeOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) graphql.Marshaler {
 5595	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5596	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 5597	rctx := &graphql.ResolverContext{
 5598		Object:   "LabelChangeOperation",
 5599		Field:    field,
 5600		Args:     nil,
 5601		IsMethod: false,
 5602	}
 5603	ctx = graphql.WithResolverContext(ctx, rctx)
 5604	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5605	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 5606		ctx = rctx // use context from middleware stack in children
 5607		return obj.Author, nil
 5608	})
 5609	if resTmp == nil {
 5610		if !ec.HasError(rctx) {
 5611			ec.Errorf(ctx, "must not be null")
 5612		}
 5613		return graphql.Null
 5614	}
 5615	res := resTmp.(identity.Interface)
 5616	rctx.Result = res
 5617	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5618	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
 5619}
 5620
 5621func (ec *executionContext) _LabelChangeOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) graphql.Marshaler {
 5622	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5623	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 5624	rctx := &graphql.ResolverContext{
 5625		Object:   "LabelChangeOperation",
 5626		Field:    field,
 5627		Args:     nil,
 5628		IsMethod: true,
 5629	}
 5630	ctx = graphql.WithResolverContext(ctx, rctx)
 5631	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5632	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 5633		ctx = rctx // use context from middleware stack in children
 5634		return ec.resolvers.LabelChangeOperation().Date(rctx, obj)
 5635	})
 5636	if resTmp == nil {
 5637		if !ec.HasError(rctx) {
 5638			ec.Errorf(ctx, "must not be null")
 5639		}
 5640		return graphql.Null
 5641	}
 5642	res := resTmp.(*time.Time)
 5643	rctx.Result = res
 5644	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5645	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 5646}
 5647
 5648func (ec *executionContext) _LabelChangeOperation_added(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) graphql.Marshaler {
 5649	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5650	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 5651	rctx := &graphql.ResolverContext{
 5652		Object:   "LabelChangeOperation",
 5653		Field:    field,
 5654		Args:     nil,
 5655		IsMethod: false,
 5656	}
 5657	ctx = graphql.WithResolverContext(ctx, rctx)
 5658	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5659	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 5660		ctx = rctx // use context from middleware stack in children
 5661		return obj.Added, nil
 5662	})
 5663	if resTmp == nil {
 5664		if !ec.HasError(rctx) {
 5665			ec.Errorf(ctx, "must not be null")
 5666		}
 5667		return graphql.Null
 5668	}
 5669	res := resTmp.([]bug.Label)
 5670	rctx.Result = res
 5671	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5672	return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
 5673}
 5674
 5675func (ec *executionContext) _LabelChangeOperation_removed(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeOperation) graphql.Marshaler {
 5676	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5677	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 5678	rctx := &graphql.ResolverContext{
 5679		Object:   "LabelChangeOperation",
 5680		Field:    field,
 5681		Args:     nil,
 5682		IsMethod: false,
 5683	}
 5684	ctx = graphql.WithResolverContext(ctx, rctx)
 5685	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5686	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 5687		ctx = rctx // use context from middleware stack in children
 5688		return obj.Removed, nil
 5689	})
 5690	if resTmp == nil {
 5691		if !ec.HasError(rctx) {
 5692			ec.Errorf(ctx, "must not be null")
 5693		}
 5694		return graphql.Null
 5695	}
 5696	res := resTmp.([]bug.Label)
 5697	rctx.Result = res
 5698	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5699	return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
 5700}
 5701
 5702func (ec *executionContext) _LabelChangeResult_label(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeResult) graphql.Marshaler {
 5703	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5704	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 5705	rctx := &graphql.ResolverContext{
 5706		Object:   "LabelChangeResult",
 5707		Field:    field,
 5708		Args:     nil,
 5709		IsMethod: false,
 5710	}
 5711	ctx = graphql.WithResolverContext(ctx, rctx)
 5712	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5713	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 5714		ctx = rctx // use context from middleware stack in children
 5715		return obj.Label, nil
 5716	})
 5717	if resTmp == nil {
 5718		if !ec.HasError(rctx) {
 5719			ec.Errorf(ctx, "must not be null")
 5720		}
 5721		return graphql.Null
 5722	}
 5723	res := resTmp.(bug.Label)
 5724	rctx.Result = res
 5725	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5726	return ec.marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
 5727}
 5728
 5729func (ec *executionContext) _LabelChangeResult_status(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeResult) graphql.Marshaler {
 5730	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5731	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 5732	rctx := &graphql.ResolverContext{
 5733		Object:   "LabelChangeResult",
 5734		Field:    field,
 5735		Args:     nil,
 5736		IsMethod: true,
 5737	}
 5738	ctx = graphql.WithResolverContext(ctx, rctx)
 5739	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5740	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 5741		ctx = rctx // use context from middleware stack in children
 5742		return ec.resolvers.LabelChangeResult().Status(rctx, obj)
 5743	})
 5744	if resTmp == nil {
 5745		if !ec.HasError(rctx) {
 5746			ec.Errorf(ctx, "must not be null")
 5747		}
 5748		return graphql.Null
 5749	}
 5750	res := resTmp.(models.LabelChangeStatus)
 5751	rctx.Result = res
 5752	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5753	return ec.marshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx, field.Selections, res)
 5754}
 5755
 5756func (ec *executionContext) _LabelChangeTimelineItem_hash(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) graphql.Marshaler {
 5757	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5758	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 5759	rctx := &graphql.ResolverContext{
 5760		Object:   "LabelChangeTimelineItem",
 5761		Field:    field,
 5762		Args:     nil,
 5763		IsMethod: true,
 5764	}
 5765	ctx = graphql.WithResolverContext(ctx, rctx)
 5766	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5767	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 5768		ctx = rctx // use context from middleware stack in children
 5769		return obj.Hash(), nil
 5770	})
 5771	if resTmp == nil {
 5772		if !ec.HasError(rctx) {
 5773			ec.Errorf(ctx, "must not be null")
 5774		}
 5775		return graphql.Null
 5776	}
 5777	res := resTmp.(git.Hash)
 5778	rctx.Result = res
 5779	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5780	return ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
 5781}
 5782
 5783func (ec *executionContext) _LabelChangeTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) graphql.Marshaler {
 5784	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5785	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 5786	rctx := &graphql.ResolverContext{
 5787		Object:   "LabelChangeTimelineItem",
 5788		Field:    field,
 5789		Args:     nil,
 5790		IsMethod: false,
 5791	}
 5792	ctx = graphql.WithResolverContext(ctx, rctx)
 5793	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5794	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 5795		ctx = rctx // use context from middleware stack in children
 5796		return obj.Author, nil
 5797	})
 5798	if resTmp == nil {
 5799		if !ec.HasError(rctx) {
 5800			ec.Errorf(ctx, "must not be null")
 5801		}
 5802		return graphql.Null
 5803	}
 5804	res := resTmp.(identity.Interface)
 5805	rctx.Result = res
 5806	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5807	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
 5808}
 5809
 5810func (ec *executionContext) _LabelChangeTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) graphql.Marshaler {
 5811	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5812	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 5813	rctx := &graphql.ResolverContext{
 5814		Object:   "LabelChangeTimelineItem",
 5815		Field:    field,
 5816		Args:     nil,
 5817		IsMethod: true,
 5818	}
 5819	ctx = graphql.WithResolverContext(ctx, rctx)
 5820	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5821	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 5822		ctx = rctx // use context from middleware stack in children
 5823		return ec.resolvers.LabelChangeTimelineItem().Date(rctx, obj)
 5824	})
 5825	if resTmp == nil {
 5826		if !ec.HasError(rctx) {
 5827			ec.Errorf(ctx, "must not be null")
 5828		}
 5829		return graphql.Null
 5830	}
 5831	res := resTmp.(*time.Time)
 5832	rctx.Result = res
 5833	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5834	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 5835}
 5836
 5837func (ec *executionContext) _LabelChangeTimelineItem_added(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) graphql.Marshaler {
 5838	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5839	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 5840	rctx := &graphql.ResolverContext{
 5841		Object:   "LabelChangeTimelineItem",
 5842		Field:    field,
 5843		Args:     nil,
 5844		IsMethod: false,
 5845	}
 5846	ctx = graphql.WithResolverContext(ctx, rctx)
 5847	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5848	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 5849		ctx = rctx // use context from middleware stack in children
 5850		return obj.Added, nil
 5851	})
 5852	if resTmp == nil {
 5853		if !ec.HasError(rctx) {
 5854			ec.Errorf(ctx, "must not be null")
 5855		}
 5856		return graphql.Null
 5857	}
 5858	res := resTmp.([]bug.Label)
 5859	rctx.Result = res
 5860	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5861	return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
 5862}
 5863
 5864func (ec *executionContext) _LabelChangeTimelineItem_removed(ctx context.Context, field graphql.CollectedField, obj *bug.LabelChangeTimelineItem) graphql.Marshaler {
 5865	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5866	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 5867	rctx := &graphql.ResolverContext{
 5868		Object:   "LabelChangeTimelineItem",
 5869		Field:    field,
 5870		Args:     nil,
 5871		IsMethod: false,
 5872	}
 5873	ctx = graphql.WithResolverContext(ctx, rctx)
 5874	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5875	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 5876		ctx = rctx // use context from middleware stack in children
 5877		return obj.Removed, nil
 5878	})
 5879	if resTmp == nil {
 5880		if !ec.HasError(rctx) {
 5881			ec.Errorf(ctx, "must not be null")
 5882		}
 5883		return graphql.Null
 5884	}
 5885	res := resTmp.([]bug.Label)
 5886	rctx.Result = res
 5887	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5888	return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
 5889}
 5890
 5891func (ec *executionContext) _Mutation_newBug(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
 5892	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5893	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 5894	rctx := &graphql.ResolverContext{
 5895		Object:   "Mutation",
 5896		Field:    field,
 5897		Args:     nil,
 5898		IsMethod: true,
 5899	}
 5900	ctx = graphql.WithResolverContext(ctx, rctx)
 5901	rawArgs := field.ArgumentMap(ec.Variables)
 5902	args, err := ec.field_Mutation_newBug_args(ctx, rawArgs)
 5903	if err != nil {
 5904		ec.Error(ctx, err)
 5905		return graphql.Null
 5906	}
 5907	rctx.Args = args
 5908	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5909	resTmp := ec.FieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
 5910		ctx = rctx // use context from middleware stack in children
 5911		return ec.resolvers.Mutation().NewBug(rctx, args["input"].(models.NewBugInput))
 5912	})
 5913	if resTmp == nil {
 5914		if !ec.HasError(rctx) {
 5915			ec.Errorf(ctx, "must not be null")
 5916		}
 5917		return graphql.Null
 5918	}
 5919	res := resTmp.(*models.NewBugPayload)
 5920	rctx.Result = res
 5921	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5922	return ec.marshalNNewBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugPayload(ctx, field.Selections, res)
 5923}
 5924
 5925func (ec *executionContext) _Mutation_addComment(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
 5926	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5927	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 5928	rctx := &graphql.ResolverContext{
 5929		Object:   "Mutation",
 5930		Field:    field,
 5931		Args:     nil,
 5932		IsMethod: true,
 5933	}
 5934	ctx = graphql.WithResolverContext(ctx, rctx)
 5935	rawArgs := field.ArgumentMap(ec.Variables)
 5936	args, err := ec.field_Mutation_addComment_args(ctx, rawArgs)
 5937	if err != nil {
 5938		ec.Error(ctx, err)
 5939		return graphql.Null
 5940	}
 5941	rctx.Args = args
 5942	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5943	resTmp := ec.FieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
 5944		ctx = rctx // use context from middleware stack in children
 5945		return ec.resolvers.Mutation().AddComment(rctx, args["input"].(models.AddCommentInput))
 5946	})
 5947	if resTmp == nil {
 5948		if !ec.HasError(rctx) {
 5949			ec.Errorf(ctx, "must not be null")
 5950		}
 5951		return graphql.Null
 5952	}
 5953	res := resTmp.(*models.AddCommentPayload)
 5954	rctx.Result = res
 5955	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5956	return ec.marshalNAddCommentPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx, field.Selections, res)
 5957}
 5958
 5959func (ec *executionContext) _Mutation_changeLabels(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
 5960	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5961	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 5962	rctx := &graphql.ResolverContext{
 5963		Object:   "Mutation",
 5964		Field:    field,
 5965		Args:     nil,
 5966		IsMethod: true,
 5967	}
 5968	ctx = graphql.WithResolverContext(ctx, rctx)
 5969	rawArgs := field.ArgumentMap(ec.Variables)
 5970	args, err := ec.field_Mutation_changeLabels_args(ctx, rawArgs)
 5971	if err != nil {
 5972		ec.Error(ctx, err)
 5973		return graphql.Null
 5974	}
 5975	rctx.Args = args
 5976	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 5977	resTmp := ec.FieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
 5978		ctx = rctx // use context from middleware stack in children
 5979		return ec.resolvers.Mutation().ChangeLabels(rctx, args["input"].(*models.ChangeLabelInput))
 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.(*models.ChangeLabelPayload)
 5988	rctx.Result = res
 5989	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 5990	return ec.marshalNChangeLabelPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx, field.Selections, res)
 5991}
 5992
 5993func (ec *executionContext) _Mutation_openBug(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
 5994	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 5995	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 5996	rctx := &graphql.ResolverContext{
 5997		Object:   "Mutation",
 5998		Field:    field,
 5999		Args:     nil,
 6000		IsMethod: true,
 6001	}
 6002	ctx = graphql.WithResolverContext(ctx, rctx)
 6003	rawArgs := field.ArgumentMap(ec.Variables)
 6004	args, err := ec.field_Mutation_openBug_args(ctx, rawArgs)
 6005	if err != nil {
 6006		ec.Error(ctx, err)
 6007		return graphql.Null
 6008	}
 6009	rctx.Args = args
 6010	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6011	resTmp := ec.FieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
 6012		ctx = rctx // use context from middleware stack in children
 6013		return ec.resolvers.Mutation().OpenBug(rctx, args["input"].(models.OpenBugInput))
 6014	})
 6015	if resTmp == nil {
 6016		if !ec.HasError(rctx) {
 6017			ec.Errorf(ctx, "must not be null")
 6018		}
 6019		return graphql.Null
 6020	}
 6021	res := resTmp.(*models.OpenBugPayload)
 6022	rctx.Result = res
 6023	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6024	return ec.marshalNOpenBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx, field.Selections, res)
 6025}
 6026
 6027func (ec *executionContext) _Mutation_closeBug(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
 6028	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6029	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 6030	rctx := &graphql.ResolverContext{
 6031		Object:   "Mutation",
 6032		Field:    field,
 6033		Args:     nil,
 6034		IsMethod: true,
 6035	}
 6036	ctx = graphql.WithResolverContext(ctx, rctx)
 6037	rawArgs := field.ArgumentMap(ec.Variables)
 6038	args, err := ec.field_Mutation_closeBug_args(ctx, rawArgs)
 6039	if err != nil {
 6040		ec.Error(ctx, err)
 6041		return graphql.Null
 6042	}
 6043	rctx.Args = args
 6044	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6045	resTmp := ec.FieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
 6046		ctx = rctx // use context from middleware stack in children
 6047		return ec.resolvers.Mutation().CloseBug(rctx, args["input"].(models.CloseBugInput))
 6048	})
 6049	if resTmp == nil {
 6050		if !ec.HasError(rctx) {
 6051			ec.Errorf(ctx, "must not be null")
 6052		}
 6053		return graphql.Null
 6054	}
 6055	res := resTmp.(*models.CloseBugPayload)
 6056	rctx.Result = res
 6057	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6058	return ec.marshalNCloseBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx, field.Selections, res)
 6059}
 6060
 6061func (ec *executionContext) _Mutation_setTitle(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
 6062	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6063	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 6064	rctx := &graphql.ResolverContext{
 6065		Object:   "Mutation",
 6066		Field:    field,
 6067		Args:     nil,
 6068		IsMethod: true,
 6069	}
 6070	ctx = graphql.WithResolverContext(ctx, rctx)
 6071	rawArgs := field.ArgumentMap(ec.Variables)
 6072	args, err := ec.field_Mutation_setTitle_args(ctx, rawArgs)
 6073	if err != nil {
 6074		ec.Error(ctx, err)
 6075		return graphql.Null
 6076	}
 6077	rctx.Args = args
 6078	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6079	resTmp := ec.FieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
 6080		ctx = rctx // use context from middleware stack in children
 6081		return ec.resolvers.Mutation().SetTitle(rctx, args["input"].(models.SetTitleInput))
 6082	})
 6083	if resTmp == nil {
 6084		if !ec.HasError(rctx) {
 6085			ec.Errorf(ctx, "must not be null")
 6086		}
 6087		return graphql.Null
 6088	}
 6089	res := resTmp.(*models.SetTitlePayload)
 6090	rctx.Result = res
 6091	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6092	return ec.marshalNSetTitlePayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx, field.Selections, res)
 6093}
 6094
 6095func (ec *executionContext) _Mutation_commit(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
 6096	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6097	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 6098	rctx := &graphql.ResolverContext{
 6099		Object:   "Mutation",
 6100		Field:    field,
 6101		Args:     nil,
 6102		IsMethod: true,
 6103	}
 6104	ctx = graphql.WithResolverContext(ctx, rctx)
 6105	rawArgs := field.ArgumentMap(ec.Variables)
 6106	args, err := ec.field_Mutation_commit_args(ctx, rawArgs)
 6107	if err != nil {
 6108		ec.Error(ctx, err)
 6109		return graphql.Null
 6110	}
 6111	rctx.Args = args
 6112	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6113	resTmp := ec.FieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
 6114		ctx = rctx // use context from middleware stack in children
 6115		return ec.resolvers.Mutation().Commit(rctx, args["input"].(models.CommitInput))
 6116	})
 6117	if resTmp == nil {
 6118		if !ec.HasError(rctx) {
 6119			ec.Errorf(ctx, "must not be null")
 6120		}
 6121		return graphql.Null
 6122	}
 6123	res := resTmp.(*models.CommitPayload)
 6124	rctx.Result = res
 6125	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6126	return ec.marshalNCommitPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitPayload(ctx, field.Selections, res)
 6127}
 6128
 6129func (ec *executionContext) _Mutation_commitAsNeeded(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
 6130	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6131	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 6132	rctx := &graphql.ResolverContext{
 6133		Object:   "Mutation",
 6134		Field:    field,
 6135		Args:     nil,
 6136		IsMethod: true,
 6137	}
 6138	ctx = graphql.WithResolverContext(ctx, rctx)
 6139	rawArgs := field.ArgumentMap(ec.Variables)
 6140	args, err := ec.field_Mutation_commitAsNeeded_args(ctx, rawArgs)
 6141	if err != nil {
 6142		ec.Error(ctx, err)
 6143		return graphql.Null
 6144	}
 6145	rctx.Args = args
 6146	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6147	resTmp := ec.FieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
 6148		ctx = rctx // use context from middleware stack in children
 6149		return ec.resolvers.Mutation().CommitAsNeeded(rctx, args["input"].(models.CommitAsNeededInput))
 6150	})
 6151	if resTmp == nil {
 6152		if !ec.HasError(rctx) {
 6153			ec.Errorf(ctx, "must not be null")
 6154		}
 6155		return graphql.Null
 6156	}
 6157	res := resTmp.(*models.CommitAsNeededPayload)
 6158	rctx.Result = res
 6159	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6160	return ec.marshalNCommitAsNeededPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitAsNeededPayload(ctx, field.Selections, res)
 6161}
 6162
 6163func (ec *executionContext) _NewBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) graphql.Marshaler {
 6164	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6165	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 6166	rctx := &graphql.ResolverContext{
 6167		Object:   "NewBugPayload",
 6168		Field:    field,
 6169		Args:     nil,
 6170		IsMethod: false,
 6171	}
 6172	ctx = graphql.WithResolverContext(ctx, rctx)
 6173	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6174	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 6175		ctx = rctx // use context from middleware stack in children
 6176		return obj.ClientMutationID, nil
 6177	})
 6178	if resTmp == nil {
 6179		return graphql.Null
 6180	}
 6181	res := resTmp.(*string)
 6182	rctx.Result = res
 6183	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6184	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 6185}
 6186
 6187func (ec *executionContext) _NewBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) graphql.Marshaler {
 6188	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6189	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 6190	rctx := &graphql.ResolverContext{
 6191		Object:   "NewBugPayload",
 6192		Field:    field,
 6193		Args:     nil,
 6194		IsMethod: false,
 6195	}
 6196	ctx = graphql.WithResolverContext(ctx, rctx)
 6197	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6198	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 6199		ctx = rctx // use context from middleware stack in children
 6200		return obj.Bug, nil
 6201	})
 6202	if resTmp == nil {
 6203		if !ec.HasError(rctx) {
 6204			ec.Errorf(ctx, "must not be null")
 6205		}
 6206		return graphql.Null
 6207	}
 6208	res := resTmp.(*bug.Snapshot)
 6209	rctx.Result = res
 6210	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6211	return ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
 6212}
 6213
 6214func (ec *executionContext) _NewBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.NewBugPayload) graphql.Marshaler {
 6215	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6216	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 6217	rctx := &graphql.ResolverContext{
 6218		Object:   "NewBugPayload",
 6219		Field:    field,
 6220		Args:     nil,
 6221		IsMethod: false,
 6222	}
 6223	ctx = graphql.WithResolverContext(ctx, rctx)
 6224	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6225	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 6226		ctx = rctx // use context from middleware stack in children
 6227		return obj.Operation, nil
 6228	})
 6229	if resTmp == nil {
 6230		if !ec.HasError(rctx) {
 6231			ec.Errorf(ctx, "must not be null")
 6232		}
 6233		return graphql.Null
 6234	}
 6235	res := resTmp.(*bug.CreateOperation)
 6236	rctx.Result = res
 6237	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6238	return ec.marshalNCreateOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCreateOperation(ctx, field.Selections, res)
 6239}
 6240
 6241func (ec *executionContext) _OpenBugPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) graphql.Marshaler {
 6242	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6243	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 6244	rctx := &graphql.ResolverContext{
 6245		Object:   "OpenBugPayload",
 6246		Field:    field,
 6247		Args:     nil,
 6248		IsMethod: false,
 6249	}
 6250	ctx = graphql.WithResolverContext(ctx, rctx)
 6251	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6252	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 6253		ctx = rctx // use context from middleware stack in children
 6254		return obj.ClientMutationID, nil
 6255	})
 6256	if resTmp == nil {
 6257		return graphql.Null
 6258	}
 6259	res := resTmp.(*string)
 6260	rctx.Result = res
 6261	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6262	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 6263}
 6264
 6265func (ec *executionContext) _OpenBugPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) graphql.Marshaler {
 6266	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6267	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 6268	rctx := &graphql.ResolverContext{
 6269		Object:   "OpenBugPayload",
 6270		Field:    field,
 6271		Args:     nil,
 6272		IsMethod: false,
 6273	}
 6274	ctx = graphql.WithResolverContext(ctx, rctx)
 6275	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6276	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 6277		ctx = rctx // use context from middleware stack in children
 6278		return obj.Bug, nil
 6279	})
 6280	if resTmp == nil {
 6281		if !ec.HasError(rctx) {
 6282			ec.Errorf(ctx, "must not be null")
 6283		}
 6284		return graphql.Null
 6285	}
 6286	res := resTmp.(*bug.Snapshot)
 6287	rctx.Result = res
 6288	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6289	return ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
 6290}
 6291
 6292func (ec *executionContext) _OpenBugPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.OpenBugPayload) graphql.Marshaler {
 6293	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6294	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 6295	rctx := &graphql.ResolverContext{
 6296		Object:   "OpenBugPayload",
 6297		Field:    field,
 6298		Args:     nil,
 6299		IsMethod: false,
 6300	}
 6301	ctx = graphql.WithResolverContext(ctx, rctx)
 6302	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6303	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 6304		ctx = rctx // use context from middleware stack in children
 6305		return obj.Operation, nil
 6306	})
 6307	if resTmp == nil {
 6308		if !ec.HasError(rctx) {
 6309			ec.Errorf(ctx, "must not be null")
 6310		}
 6311		return graphql.Null
 6312	}
 6313	res := resTmp.(*bug.SetStatusOperation)
 6314	rctx.Result = res
 6315	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6316	return ec.marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
 6317}
 6318
 6319func (ec *executionContext) _OperationConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) graphql.Marshaler {
 6320	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6321	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 6322	rctx := &graphql.ResolverContext{
 6323		Object:   "OperationConnection",
 6324		Field:    field,
 6325		Args:     nil,
 6326		IsMethod: false,
 6327	}
 6328	ctx = graphql.WithResolverContext(ctx, rctx)
 6329	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6330	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 6331		ctx = rctx // use context from middleware stack in children
 6332		return obj.Edges, nil
 6333	})
 6334	if resTmp == nil {
 6335		if !ec.HasError(rctx) {
 6336			ec.Errorf(ctx, "must not be null")
 6337		}
 6338		return graphql.Null
 6339	}
 6340	res := resTmp.([]*models.OperationEdge)
 6341	rctx.Result = res
 6342	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6343	return ec.marshalNOperationEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx, field.Selections, res)
 6344}
 6345
 6346func (ec *executionContext) _OperationConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) graphql.Marshaler {
 6347	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6348	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 6349	rctx := &graphql.ResolverContext{
 6350		Object:   "OperationConnection",
 6351		Field:    field,
 6352		Args:     nil,
 6353		IsMethod: false,
 6354	}
 6355	ctx = graphql.WithResolverContext(ctx, rctx)
 6356	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6357	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 6358		ctx = rctx // use context from middleware stack in children
 6359		return obj.Nodes, nil
 6360	})
 6361	if resTmp == nil {
 6362		if !ec.HasError(rctx) {
 6363			ec.Errorf(ctx, "must not be null")
 6364		}
 6365		return graphql.Null
 6366	}
 6367	res := resTmp.([]bug.Operation)
 6368	rctx.Result = res
 6369	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6370	return ec.marshalNOperation2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx, field.Selections, res)
 6371}
 6372
 6373func (ec *executionContext) _OperationConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) graphql.Marshaler {
 6374	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6375	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 6376	rctx := &graphql.ResolverContext{
 6377		Object:   "OperationConnection",
 6378		Field:    field,
 6379		Args:     nil,
 6380		IsMethod: false,
 6381	}
 6382	ctx = graphql.WithResolverContext(ctx, rctx)
 6383	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6384	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 6385		ctx = rctx // use context from middleware stack in children
 6386		return obj.PageInfo, nil
 6387	})
 6388	if resTmp == nil {
 6389		if !ec.HasError(rctx) {
 6390			ec.Errorf(ctx, "must not be null")
 6391		}
 6392		return graphql.Null
 6393	}
 6394	res := resTmp.(*models.PageInfo)
 6395	rctx.Result = res
 6396	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6397	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
 6398}
 6399
 6400func (ec *executionContext) _OperationConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.OperationConnection) graphql.Marshaler {
 6401	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6402	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 6403	rctx := &graphql.ResolverContext{
 6404		Object:   "OperationConnection",
 6405		Field:    field,
 6406		Args:     nil,
 6407		IsMethod: false,
 6408	}
 6409	ctx = graphql.WithResolverContext(ctx, rctx)
 6410	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6411	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 6412		ctx = rctx // use context from middleware stack in children
 6413		return obj.TotalCount, nil
 6414	})
 6415	if resTmp == nil {
 6416		if !ec.HasError(rctx) {
 6417			ec.Errorf(ctx, "must not be null")
 6418		}
 6419		return graphql.Null
 6420	}
 6421	res := resTmp.(int)
 6422	rctx.Result = res
 6423	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6424	return ec.marshalNInt2int(ctx, field.Selections, res)
 6425}
 6426
 6427func (ec *executionContext) _OperationEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.OperationEdge) graphql.Marshaler {
 6428	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6429	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 6430	rctx := &graphql.ResolverContext{
 6431		Object:   "OperationEdge",
 6432		Field:    field,
 6433		Args:     nil,
 6434		IsMethod: false,
 6435	}
 6436	ctx = graphql.WithResolverContext(ctx, rctx)
 6437	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6438	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 6439		ctx = rctx // use context from middleware stack in children
 6440		return obj.Cursor, nil
 6441	})
 6442	if resTmp == nil {
 6443		if !ec.HasError(rctx) {
 6444			ec.Errorf(ctx, "must not be null")
 6445		}
 6446		return graphql.Null
 6447	}
 6448	res := resTmp.(string)
 6449	rctx.Result = res
 6450	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6451	return ec.marshalNString2string(ctx, field.Selections, res)
 6452}
 6453
 6454func (ec *executionContext) _OperationEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.OperationEdge) graphql.Marshaler {
 6455	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6456	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 6457	rctx := &graphql.ResolverContext{
 6458		Object:   "OperationEdge",
 6459		Field:    field,
 6460		Args:     nil,
 6461		IsMethod: false,
 6462	}
 6463	ctx = graphql.WithResolverContext(ctx, rctx)
 6464	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6465	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 6466		ctx = rctx // use context from middleware stack in children
 6467		return obj.Node, nil
 6468	})
 6469	if resTmp == nil {
 6470		if !ec.HasError(rctx) {
 6471			ec.Errorf(ctx, "must not be null")
 6472		}
 6473		return graphql.Null
 6474	}
 6475	res := resTmp.(bug.Operation)
 6476	rctx.Result = res
 6477	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6478	return ec.marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx, field.Selections, res)
 6479}
 6480
 6481func (ec *executionContext) _PageInfo_hasNextPage(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) graphql.Marshaler {
 6482	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6483	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 6484	rctx := &graphql.ResolverContext{
 6485		Object:   "PageInfo",
 6486		Field:    field,
 6487		Args:     nil,
 6488		IsMethod: false,
 6489	}
 6490	ctx = graphql.WithResolverContext(ctx, rctx)
 6491	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6492	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 6493		ctx = rctx // use context from middleware stack in children
 6494		return obj.HasNextPage, nil
 6495	})
 6496	if resTmp == nil {
 6497		if !ec.HasError(rctx) {
 6498			ec.Errorf(ctx, "must not be null")
 6499		}
 6500		return graphql.Null
 6501	}
 6502	res := resTmp.(bool)
 6503	rctx.Result = res
 6504	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6505	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 6506}
 6507
 6508func (ec *executionContext) _PageInfo_hasPreviousPage(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) graphql.Marshaler {
 6509	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6510	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 6511	rctx := &graphql.ResolverContext{
 6512		Object:   "PageInfo",
 6513		Field:    field,
 6514		Args:     nil,
 6515		IsMethod: false,
 6516	}
 6517	ctx = graphql.WithResolverContext(ctx, rctx)
 6518	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6519	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 6520		ctx = rctx // use context from middleware stack in children
 6521		return obj.HasPreviousPage, nil
 6522	})
 6523	if resTmp == nil {
 6524		if !ec.HasError(rctx) {
 6525			ec.Errorf(ctx, "must not be null")
 6526		}
 6527		return graphql.Null
 6528	}
 6529	res := resTmp.(bool)
 6530	rctx.Result = res
 6531	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6532	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 6533}
 6534
 6535func (ec *executionContext) _PageInfo_startCursor(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) graphql.Marshaler {
 6536	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6537	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 6538	rctx := &graphql.ResolverContext{
 6539		Object:   "PageInfo",
 6540		Field:    field,
 6541		Args:     nil,
 6542		IsMethod: false,
 6543	}
 6544	ctx = graphql.WithResolverContext(ctx, rctx)
 6545	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6546	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 6547		ctx = rctx // use context from middleware stack in children
 6548		return obj.StartCursor, nil
 6549	})
 6550	if resTmp == nil {
 6551		if !ec.HasError(rctx) {
 6552			ec.Errorf(ctx, "must not be null")
 6553		}
 6554		return graphql.Null
 6555	}
 6556	res := resTmp.(string)
 6557	rctx.Result = res
 6558	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6559	return ec.marshalNString2string(ctx, field.Selections, res)
 6560}
 6561
 6562func (ec *executionContext) _PageInfo_endCursor(ctx context.Context, field graphql.CollectedField, obj *models.PageInfo) graphql.Marshaler {
 6563	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6564	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 6565	rctx := &graphql.ResolverContext{
 6566		Object:   "PageInfo",
 6567		Field:    field,
 6568		Args:     nil,
 6569		IsMethod: false,
 6570	}
 6571	ctx = graphql.WithResolverContext(ctx, rctx)
 6572	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6573	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 6574		ctx = rctx // use context from middleware stack in children
 6575		return obj.EndCursor, nil
 6576	})
 6577	if resTmp == nil {
 6578		if !ec.HasError(rctx) {
 6579			ec.Errorf(ctx, "must not be null")
 6580		}
 6581		return graphql.Null
 6582	}
 6583	res := resTmp.(string)
 6584	rctx.Result = res
 6585	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6586	return ec.marshalNString2string(ctx, field.Selections, res)
 6587}
 6588
 6589func (ec *executionContext) _Query_defaultRepository(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
 6590	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6591	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 6592	rctx := &graphql.ResolverContext{
 6593		Object:   "Query",
 6594		Field:    field,
 6595		Args:     nil,
 6596		IsMethod: true,
 6597	}
 6598	ctx = graphql.WithResolverContext(ctx, rctx)
 6599	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6600	resTmp := ec.FieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
 6601		ctx = rctx // use context from middleware stack in children
 6602		return ec.resolvers.Query().DefaultRepository(rctx)
 6603	})
 6604	if resTmp == nil {
 6605		return graphql.Null
 6606	}
 6607	res := resTmp.(*models.Repository)
 6608	rctx.Result = res
 6609	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6610	return ec.marshalORepository2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRepository(ctx, field.Selections, res)
 6611}
 6612
 6613func (ec *executionContext) _Query_repository(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
 6614	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6615	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 6616	rctx := &graphql.ResolverContext{
 6617		Object:   "Query",
 6618		Field:    field,
 6619		Args:     nil,
 6620		IsMethod: true,
 6621	}
 6622	ctx = graphql.WithResolverContext(ctx, rctx)
 6623	rawArgs := field.ArgumentMap(ec.Variables)
 6624	args, err := ec.field_Query_repository_args(ctx, rawArgs)
 6625	if err != nil {
 6626		ec.Error(ctx, err)
 6627		return graphql.Null
 6628	}
 6629	rctx.Args = args
 6630	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6631	resTmp := ec.FieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
 6632		ctx = rctx // use context from middleware stack in children
 6633		return ec.resolvers.Query().Repository(rctx, args["ref"].(string))
 6634	})
 6635	if resTmp == nil {
 6636		return graphql.Null
 6637	}
 6638	res := resTmp.(*models.Repository)
 6639	rctx.Result = res
 6640	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6641	return ec.marshalORepository2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRepository(ctx, field.Selections, res)
 6642}
 6643
 6644func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
 6645	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6646	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 6647	rctx := &graphql.ResolverContext{
 6648		Object:   "Query",
 6649		Field:    field,
 6650		Args:     nil,
 6651		IsMethod: true,
 6652	}
 6653	ctx = graphql.WithResolverContext(ctx, rctx)
 6654	rawArgs := field.ArgumentMap(ec.Variables)
 6655	args, err := ec.field_Query___type_args(ctx, rawArgs)
 6656	if err != nil {
 6657		ec.Error(ctx, err)
 6658		return graphql.Null
 6659	}
 6660	rctx.Args = args
 6661	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6662	resTmp := ec.FieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
 6663		ctx = rctx // use context from middleware stack in children
 6664		return ec.introspectType(args["name"].(string))
 6665	})
 6666	if resTmp == nil {
 6667		return graphql.Null
 6668	}
 6669	res := resTmp.(*introspection.Type)
 6670	rctx.Result = res
 6671	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6672	return ec.marshalO__Type2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
 6673}
 6674
 6675func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) graphql.Marshaler {
 6676	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6677	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 6678	rctx := &graphql.ResolverContext{
 6679		Object:   "Query",
 6680		Field:    field,
 6681		Args:     nil,
 6682		IsMethod: true,
 6683	}
 6684	ctx = graphql.WithResolverContext(ctx, rctx)
 6685	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6686	resTmp := ec.FieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) {
 6687		ctx = rctx // use context from middleware stack in children
 6688		return ec.introspectSchema()
 6689	})
 6690	if resTmp == nil {
 6691		return graphql.Null
 6692	}
 6693	res := resTmp.(*introspection.Schema)
 6694	rctx.Result = res
 6695	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6696	return ec.marshalO__Schema2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx, field.Selections, res)
 6697}
 6698
 6699func (ec *executionContext) _Repository_allBugs(ctx context.Context, field graphql.CollectedField, obj *models.Repository) graphql.Marshaler {
 6700	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6701	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 6702	rctx := &graphql.ResolverContext{
 6703		Object:   "Repository",
 6704		Field:    field,
 6705		Args:     nil,
 6706		IsMethod: true,
 6707	}
 6708	ctx = graphql.WithResolverContext(ctx, rctx)
 6709	rawArgs := field.ArgumentMap(ec.Variables)
 6710	args, err := ec.field_Repository_allBugs_args(ctx, rawArgs)
 6711	if err != nil {
 6712		ec.Error(ctx, err)
 6713		return graphql.Null
 6714	}
 6715	rctx.Args = args
 6716	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6717	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 6718		ctx = rctx // use context from middleware stack in children
 6719		return ec.resolvers.Repository().AllBugs(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int), args["query"].(*string))
 6720	})
 6721	if resTmp == nil {
 6722		if !ec.HasError(rctx) {
 6723			ec.Errorf(ctx, "must not be null")
 6724		}
 6725		return graphql.Null
 6726	}
 6727	res := resTmp.(*models.BugConnection)
 6728	rctx.Result = res
 6729	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6730	return ec.marshalNBugConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugConnection(ctx, field.Selections, res)
 6731}
 6732
 6733func (ec *executionContext) _Repository_bug(ctx context.Context, field graphql.CollectedField, obj *models.Repository) graphql.Marshaler {
 6734	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6735	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 6736	rctx := &graphql.ResolverContext{
 6737		Object:   "Repository",
 6738		Field:    field,
 6739		Args:     nil,
 6740		IsMethod: true,
 6741	}
 6742	ctx = graphql.WithResolverContext(ctx, rctx)
 6743	rawArgs := field.ArgumentMap(ec.Variables)
 6744	args, err := ec.field_Repository_bug_args(ctx, rawArgs)
 6745	if err != nil {
 6746		ec.Error(ctx, err)
 6747		return graphql.Null
 6748	}
 6749	rctx.Args = args
 6750	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6751	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 6752		ctx = rctx // use context from middleware stack in children
 6753		return ec.resolvers.Repository().Bug(rctx, obj, args["prefix"].(string))
 6754	})
 6755	if resTmp == nil {
 6756		return graphql.Null
 6757	}
 6758	res := resTmp.(*bug.Snapshot)
 6759	rctx.Result = res
 6760	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6761	return ec.marshalOBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
 6762}
 6763
 6764func (ec *executionContext) _Repository_allIdentities(ctx context.Context, field graphql.CollectedField, obj *models.Repository) graphql.Marshaler {
 6765	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6766	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 6767	rctx := &graphql.ResolverContext{
 6768		Object:   "Repository",
 6769		Field:    field,
 6770		Args:     nil,
 6771		IsMethod: true,
 6772	}
 6773	ctx = graphql.WithResolverContext(ctx, rctx)
 6774	rawArgs := field.ArgumentMap(ec.Variables)
 6775	args, err := ec.field_Repository_allIdentities_args(ctx, rawArgs)
 6776	if err != nil {
 6777		ec.Error(ctx, err)
 6778		return graphql.Null
 6779	}
 6780	rctx.Args = args
 6781	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6782	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 6783		ctx = rctx // use context from middleware stack in children
 6784		return ec.resolvers.Repository().AllIdentities(rctx, obj, args["after"].(*string), args["before"].(*string), args["first"].(*int), args["last"].(*int))
 6785	})
 6786	if resTmp == nil {
 6787		if !ec.HasError(rctx) {
 6788			ec.Errorf(ctx, "must not be null")
 6789		}
 6790		return graphql.Null
 6791	}
 6792	res := resTmp.(*models.IdentityConnection)
 6793	rctx.Result = res
 6794	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6795	return ec.marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx, field.Selections, res)
 6796}
 6797
 6798func (ec *executionContext) _Repository_identity(ctx context.Context, field graphql.CollectedField, obj *models.Repository) graphql.Marshaler {
 6799	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6800	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 6801	rctx := &graphql.ResolverContext{
 6802		Object:   "Repository",
 6803		Field:    field,
 6804		Args:     nil,
 6805		IsMethod: true,
 6806	}
 6807	ctx = graphql.WithResolverContext(ctx, rctx)
 6808	rawArgs := field.ArgumentMap(ec.Variables)
 6809	args, err := ec.field_Repository_identity_args(ctx, rawArgs)
 6810	if err != nil {
 6811		ec.Error(ctx, err)
 6812		return graphql.Null
 6813	}
 6814	rctx.Args = args
 6815	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6816	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 6817		ctx = rctx // use context from middleware stack in children
 6818		return ec.resolvers.Repository().Identity(rctx, obj, args["prefix"].(string))
 6819	})
 6820	if resTmp == nil {
 6821		return graphql.Null
 6822	}
 6823	res := resTmp.(identity.Interface)
 6824	rctx.Result = res
 6825	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6826	return ec.marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
 6827}
 6828
 6829func (ec *executionContext) _Repository_userIdentity(ctx context.Context, field graphql.CollectedField, obj *models.Repository) graphql.Marshaler {
 6830	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6831	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 6832	rctx := &graphql.ResolverContext{
 6833		Object:   "Repository",
 6834		Field:    field,
 6835		Args:     nil,
 6836		IsMethod: true,
 6837	}
 6838	ctx = graphql.WithResolverContext(ctx, rctx)
 6839	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6840	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 6841		ctx = rctx // use context from middleware stack in children
 6842		return ec.resolvers.Repository().UserIdentity(rctx, obj)
 6843	})
 6844	if resTmp == nil {
 6845		return graphql.Null
 6846	}
 6847	res := resTmp.(identity.Interface)
 6848	rctx.Result = res
 6849	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6850	return ec.marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
 6851}
 6852
 6853func (ec *executionContext) _Repository_validLabels(ctx context.Context, field graphql.CollectedField, obj *models.Repository) graphql.Marshaler {
 6854	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6855	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 6856	rctx := &graphql.ResolverContext{
 6857		Object:   "Repository",
 6858		Field:    field,
 6859		Args:     nil,
 6860		IsMethod: true,
 6861	}
 6862	ctx = graphql.WithResolverContext(ctx, rctx)
 6863	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6864	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 6865		ctx = rctx // use context from middleware stack in children
 6866		return ec.resolvers.Repository().ValidLabels(rctx, obj)
 6867	})
 6868	if resTmp == nil {
 6869		if !ec.HasError(rctx) {
 6870			ec.Errorf(ctx, "must not be null")
 6871		}
 6872		return graphql.Null
 6873	}
 6874	res := resTmp.([]bug.Label)
 6875	rctx.Result = res
 6876	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6877	return ec.marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, field.Selections, res)
 6878}
 6879
 6880func (ec *executionContext) _SetStatusOperation_hash(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) graphql.Marshaler {
 6881	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6882	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 6883	rctx := &graphql.ResolverContext{
 6884		Object:   "SetStatusOperation",
 6885		Field:    field,
 6886		Args:     nil,
 6887		IsMethod: true,
 6888	}
 6889	ctx = graphql.WithResolverContext(ctx, rctx)
 6890	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6891	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 6892		ctx = rctx // use context from middleware stack in children
 6893		return obj.Hash()
 6894	})
 6895	if resTmp == nil {
 6896		if !ec.HasError(rctx) {
 6897			ec.Errorf(ctx, "must not be null")
 6898		}
 6899		return graphql.Null
 6900	}
 6901	res := resTmp.(git.Hash)
 6902	rctx.Result = res
 6903	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6904	return ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
 6905}
 6906
 6907func (ec *executionContext) _SetStatusOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) graphql.Marshaler {
 6908	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6909	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 6910	rctx := &graphql.ResolverContext{
 6911		Object:   "SetStatusOperation",
 6912		Field:    field,
 6913		Args:     nil,
 6914		IsMethod: false,
 6915	}
 6916	ctx = graphql.WithResolverContext(ctx, rctx)
 6917	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6918	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 6919		ctx = rctx // use context from middleware stack in children
 6920		return obj.Author, nil
 6921	})
 6922	if resTmp == nil {
 6923		if !ec.HasError(rctx) {
 6924			ec.Errorf(ctx, "must not be null")
 6925		}
 6926		return graphql.Null
 6927	}
 6928	res := resTmp.(identity.Interface)
 6929	rctx.Result = res
 6930	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6931	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
 6932}
 6933
 6934func (ec *executionContext) _SetStatusOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) graphql.Marshaler {
 6935	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6936	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 6937	rctx := &graphql.ResolverContext{
 6938		Object:   "SetStatusOperation",
 6939		Field:    field,
 6940		Args:     nil,
 6941		IsMethod: true,
 6942	}
 6943	ctx = graphql.WithResolverContext(ctx, rctx)
 6944	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6945	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 6946		ctx = rctx // use context from middleware stack in children
 6947		return ec.resolvers.SetStatusOperation().Date(rctx, obj)
 6948	})
 6949	if resTmp == nil {
 6950		if !ec.HasError(rctx) {
 6951			ec.Errorf(ctx, "must not be null")
 6952		}
 6953		return graphql.Null
 6954	}
 6955	res := resTmp.(*time.Time)
 6956	rctx.Result = res
 6957	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6958	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 6959}
 6960
 6961func (ec *executionContext) _SetStatusOperation_status(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusOperation) graphql.Marshaler {
 6962	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6963	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 6964	rctx := &graphql.ResolverContext{
 6965		Object:   "SetStatusOperation",
 6966		Field:    field,
 6967		Args:     nil,
 6968		IsMethod: true,
 6969	}
 6970	ctx = graphql.WithResolverContext(ctx, rctx)
 6971	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6972	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 6973		ctx = rctx // use context from middleware stack in children
 6974		return ec.resolvers.SetStatusOperation().Status(rctx, obj)
 6975	})
 6976	if resTmp == nil {
 6977		if !ec.HasError(rctx) {
 6978			ec.Errorf(ctx, "must not be null")
 6979		}
 6980		return graphql.Null
 6981	}
 6982	res := resTmp.(models.Status)
 6983	rctx.Result = res
 6984	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 6985	return ec.marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx, field.Selections, res)
 6986}
 6987
 6988func (ec *executionContext) _SetStatusTimelineItem_hash(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) graphql.Marshaler {
 6989	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 6990	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 6991	rctx := &graphql.ResolverContext{
 6992		Object:   "SetStatusTimelineItem",
 6993		Field:    field,
 6994		Args:     nil,
 6995		IsMethod: true,
 6996	}
 6997	ctx = graphql.WithResolverContext(ctx, rctx)
 6998	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 6999	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 7000		ctx = rctx // use context from middleware stack in children
 7001		return obj.Hash(), nil
 7002	})
 7003	if resTmp == nil {
 7004		if !ec.HasError(rctx) {
 7005			ec.Errorf(ctx, "must not be null")
 7006		}
 7007		return graphql.Null
 7008	}
 7009	res := resTmp.(git.Hash)
 7010	rctx.Result = res
 7011	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7012	return ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
 7013}
 7014
 7015func (ec *executionContext) _SetStatusTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) graphql.Marshaler {
 7016	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7017	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 7018	rctx := &graphql.ResolverContext{
 7019		Object:   "SetStatusTimelineItem",
 7020		Field:    field,
 7021		Args:     nil,
 7022		IsMethod: false,
 7023	}
 7024	ctx = graphql.WithResolverContext(ctx, rctx)
 7025	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7026	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 7027		ctx = rctx // use context from middleware stack in children
 7028		return obj.Author, nil
 7029	})
 7030	if resTmp == nil {
 7031		if !ec.HasError(rctx) {
 7032			ec.Errorf(ctx, "must not be null")
 7033		}
 7034		return graphql.Null
 7035	}
 7036	res := resTmp.(identity.Interface)
 7037	rctx.Result = res
 7038	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7039	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
 7040}
 7041
 7042func (ec *executionContext) _SetStatusTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) graphql.Marshaler {
 7043	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7044	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 7045	rctx := &graphql.ResolverContext{
 7046		Object:   "SetStatusTimelineItem",
 7047		Field:    field,
 7048		Args:     nil,
 7049		IsMethod: true,
 7050	}
 7051	ctx = graphql.WithResolverContext(ctx, rctx)
 7052	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7053	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 7054		ctx = rctx // use context from middleware stack in children
 7055		return ec.resolvers.SetStatusTimelineItem().Date(rctx, obj)
 7056	})
 7057	if resTmp == nil {
 7058		if !ec.HasError(rctx) {
 7059			ec.Errorf(ctx, "must not be null")
 7060		}
 7061		return graphql.Null
 7062	}
 7063	res := resTmp.(*time.Time)
 7064	rctx.Result = res
 7065	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7066	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 7067}
 7068
 7069func (ec *executionContext) _SetStatusTimelineItem_status(ctx context.Context, field graphql.CollectedField, obj *bug.SetStatusTimelineItem) graphql.Marshaler {
 7070	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7071	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 7072	rctx := &graphql.ResolverContext{
 7073		Object:   "SetStatusTimelineItem",
 7074		Field:    field,
 7075		Args:     nil,
 7076		IsMethod: true,
 7077	}
 7078	ctx = graphql.WithResolverContext(ctx, rctx)
 7079	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7080	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 7081		ctx = rctx // use context from middleware stack in children
 7082		return ec.resolvers.SetStatusTimelineItem().Status(rctx, obj)
 7083	})
 7084	if resTmp == nil {
 7085		if !ec.HasError(rctx) {
 7086			ec.Errorf(ctx, "must not be null")
 7087		}
 7088		return graphql.Null
 7089	}
 7090	res := resTmp.(models.Status)
 7091	rctx.Result = res
 7092	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7093	return ec.marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx, field.Selections, res)
 7094}
 7095
 7096func (ec *executionContext) _SetTitleOperation_hash(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) graphql.Marshaler {
 7097	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7098	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 7099	rctx := &graphql.ResolverContext{
 7100		Object:   "SetTitleOperation",
 7101		Field:    field,
 7102		Args:     nil,
 7103		IsMethod: true,
 7104	}
 7105	ctx = graphql.WithResolverContext(ctx, rctx)
 7106	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7107	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 7108		ctx = rctx // use context from middleware stack in children
 7109		return obj.Hash()
 7110	})
 7111	if resTmp == nil {
 7112		if !ec.HasError(rctx) {
 7113			ec.Errorf(ctx, "must not be null")
 7114		}
 7115		return graphql.Null
 7116	}
 7117	res := resTmp.(git.Hash)
 7118	rctx.Result = res
 7119	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7120	return ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
 7121}
 7122
 7123func (ec *executionContext) _SetTitleOperation_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) graphql.Marshaler {
 7124	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7125	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 7126	rctx := &graphql.ResolverContext{
 7127		Object:   "SetTitleOperation",
 7128		Field:    field,
 7129		Args:     nil,
 7130		IsMethod: false,
 7131	}
 7132	ctx = graphql.WithResolverContext(ctx, rctx)
 7133	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7134	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 7135		ctx = rctx // use context from middleware stack in children
 7136		return obj.Author, nil
 7137	})
 7138	if resTmp == nil {
 7139		if !ec.HasError(rctx) {
 7140			ec.Errorf(ctx, "must not be null")
 7141		}
 7142		return graphql.Null
 7143	}
 7144	res := resTmp.(identity.Interface)
 7145	rctx.Result = res
 7146	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7147	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
 7148}
 7149
 7150func (ec *executionContext) _SetTitleOperation_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) graphql.Marshaler {
 7151	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7152	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 7153	rctx := &graphql.ResolverContext{
 7154		Object:   "SetTitleOperation",
 7155		Field:    field,
 7156		Args:     nil,
 7157		IsMethod: true,
 7158	}
 7159	ctx = graphql.WithResolverContext(ctx, rctx)
 7160	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7161	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 7162		ctx = rctx // use context from middleware stack in children
 7163		return ec.resolvers.SetTitleOperation().Date(rctx, obj)
 7164	})
 7165	if resTmp == nil {
 7166		if !ec.HasError(rctx) {
 7167			ec.Errorf(ctx, "must not be null")
 7168		}
 7169		return graphql.Null
 7170	}
 7171	res := resTmp.(*time.Time)
 7172	rctx.Result = res
 7173	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7174	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 7175}
 7176
 7177func (ec *executionContext) _SetTitleOperation_title(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) graphql.Marshaler {
 7178	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7179	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 7180	rctx := &graphql.ResolverContext{
 7181		Object:   "SetTitleOperation",
 7182		Field:    field,
 7183		Args:     nil,
 7184		IsMethod: false,
 7185	}
 7186	ctx = graphql.WithResolverContext(ctx, rctx)
 7187	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7188	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 7189		ctx = rctx // use context from middleware stack in children
 7190		return obj.Title, nil
 7191	})
 7192	if resTmp == nil {
 7193		if !ec.HasError(rctx) {
 7194			ec.Errorf(ctx, "must not be null")
 7195		}
 7196		return graphql.Null
 7197	}
 7198	res := resTmp.(string)
 7199	rctx.Result = res
 7200	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7201	return ec.marshalNString2string(ctx, field.Selections, res)
 7202}
 7203
 7204func (ec *executionContext) _SetTitleOperation_was(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleOperation) graphql.Marshaler {
 7205	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7206	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 7207	rctx := &graphql.ResolverContext{
 7208		Object:   "SetTitleOperation",
 7209		Field:    field,
 7210		Args:     nil,
 7211		IsMethod: false,
 7212	}
 7213	ctx = graphql.WithResolverContext(ctx, rctx)
 7214	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7215	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 7216		ctx = rctx // use context from middleware stack in children
 7217		return obj.Was, nil
 7218	})
 7219	if resTmp == nil {
 7220		if !ec.HasError(rctx) {
 7221			ec.Errorf(ctx, "must not be null")
 7222		}
 7223		return graphql.Null
 7224	}
 7225	res := resTmp.(string)
 7226	rctx.Result = res
 7227	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7228	return ec.marshalNString2string(ctx, field.Selections, res)
 7229}
 7230
 7231func (ec *executionContext) _SetTitlePayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) graphql.Marshaler {
 7232	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7233	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 7234	rctx := &graphql.ResolverContext{
 7235		Object:   "SetTitlePayload",
 7236		Field:    field,
 7237		Args:     nil,
 7238		IsMethod: false,
 7239	}
 7240	ctx = graphql.WithResolverContext(ctx, rctx)
 7241	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7242	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 7243		ctx = rctx // use context from middleware stack in children
 7244		return obj.ClientMutationID, nil
 7245	})
 7246	if resTmp == nil {
 7247		return graphql.Null
 7248	}
 7249	res := resTmp.(*string)
 7250	rctx.Result = res
 7251	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7252	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 7253}
 7254
 7255func (ec *executionContext) _SetTitlePayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) graphql.Marshaler {
 7256	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7257	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 7258	rctx := &graphql.ResolverContext{
 7259		Object:   "SetTitlePayload",
 7260		Field:    field,
 7261		Args:     nil,
 7262		IsMethod: false,
 7263	}
 7264	ctx = graphql.WithResolverContext(ctx, rctx)
 7265	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7266	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 7267		ctx = rctx // use context from middleware stack in children
 7268		return obj.Bug, nil
 7269	})
 7270	if resTmp == nil {
 7271		if !ec.HasError(rctx) {
 7272			ec.Errorf(ctx, "must not be null")
 7273		}
 7274		return graphql.Null
 7275	}
 7276	res := resTmp.(*bug.Snapshot)
 7277	rctx.Result = res
 7278	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7279	return ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, field.Selections, res)
 7280}
 7281
 7282func (ec *executionContext) _SetTitlePayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.SetTitlePayload) graphql.Marshaler {
 7283	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7284	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 7285	rctx := &graphql.ResolverContext{
 7286		Object:   "SetTitlePayload",
 7287		Field:    field,
 7288		Args:     nil,
 7289		IsMethod: false,
 7290	}
 7291	ctx = graphql.WithResolverContext(ctx, rctx)
 7292	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7293	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 7294		ctx = rctx // use context from middleware stack in children
 7295		return obj.Operation, nil
 7296	})
 7297	if resTmp == nil {
 7298		if !ec.HasError(rctx) {
 7299			ec.Errorf(ctx, "must not be null")
 7300		}
 7301		return graphql.Null
 7302	}
 7303	res := resTmp.(*bug.SetTitleOperation)
 7304	rctx.Result = res
 7305	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7306	return ec.marshalNSetTitleOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetTitleOperation(ctx, field.Selections, res)
 7307}
 7308
 7309func (ec *executionContext) _SetTitleTimelineItem_hash(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) graphql.Marshaler {
 7310	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7311	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 7312	rctx := &graphql.ResolverContext{
 7313		Object:   "SetTitleTimelineItem",
 7314		Field:    field,
 7315		Args:     nil,
 7316		IsMethod: true,
 7317	}
 7318	ctx = graphql.WithResolverContext(ctx, rctx)
 7319	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7320	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 7321		ctx = rctx // use context from middleware stack in children
 7322		return obj.Hash(), nil
 7323	})
 7324	if resTmp == nil {
 7325		if !ec.HasError(rctx) {
 7326			ec.Errorf(ctx, "must not be null")
 7327		}
 7328		return graphql.Null
 7329	}
 7330	res := resTmp.(git.Hash)
 7331	rctx.Result = res
 7332	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7333	return ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, field.Selections, res)
 7334}
 7335
 7336func (ec *executionContext) _SetTitleTimelineItem_author(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) graphql.Marshaler {
 7337	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7338	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 7339	rctx := &graphql.ResolverContext{
 7340		Object:   "SetTitleTimelineItem",
 7341		Field:    field,
 7342		Args:     nil,
 7343		IsMethod: false,
 7344	}
 7345	ctx = graphql.WithResolverContext(ctx, rctx)
 7346	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7347	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 7348		ctx = rctx // use context from middleware stack in children
 7349		return obj.Author, nil
 7350	})
 7351	if resTmp == nil {
 7352		if !ec.HasError(rctx) {
 7353			ec.Errorf(ctx, "must not be null")
 7354		}
 7355		return graphql.Null
 7356	}
 7357	res := resTmp.(identity.Interface)
 7358	rctx.Result = res
 7359	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7360	return ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, field.Selections, res)
 7361}
 7362
 7363func (ec *executionContext) _SetTitleTimelineItem_date(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) graphql.Marshaler {
 7364	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7365	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 7366	rctx := &graphql.ResolverContext{
 7367		Object:   "SetTitleTimelineItem",
 7368		Field:    field,
 7369		Args:     nil,
 7370		IsMethod: true,
 7371	}
 7372	ctx = graphql.WithResolverContext(ctx, rctx)
 7373	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7374	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 7375		ctx = rctx // use context from middleware stack in children
 7376		return ec.resolvers.SetTitleTimelineItem().Date(rctx, obj)
 7377	})
 7378	if resTmp == nil {
 7379		if !ec.HasError(rctx) {
 7380			ec.Errorf(ctx, "must not be null")
 7381		}
 7382		return graphql.Null
 7383	}
 7384	res := resTmp.(*time.Time)
 7385	rctx.Result = res
 7386	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7387	return ec.marshalNTime2ᚖtimeᚐTime(ctx, field.Selections, res)
 7388}
 7389
 7390func (ec *executionContext) _SetTitleTimelineItem_title(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) graphql.Marshaler {
 7391	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7392	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 7393	rctx := &graphql.ResolverContext{
 7394		Object:   "SetTitleTimelineItem",
 7395		Field:    field,
 7396		Args:     nil,
 7397		IsMethod: false,
 7398	}
 7399	ctx = graphql.WithResolverContext(ctx, rctx)
 7400	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7401	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 7402		ctx = rctx // use context from middleware stack in children
 7403		return obj.Title, nil
 7404	})
 7405	if resTmp == nil {
 7406		if !ec.HasError(rctx) {
 7407			ec.Errorf(ctx, "must not be null")
 7408		}
 7409		return graphql.Null
 7410	}
 7411	res := resTmp.(string)
 7412	rctx.Result = res
 7413	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7414	return ec.marshalNString2string(ctx, field.Selections, res)
 7415}
 7416
 7417func (ec *executionContext) _SetTitleTimelineItem_was(ctx context.Context, field graphql.CollectedField, obj *bug.SetTitleTimelineItem) graphql.Marshaler {
 7418	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7419	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 7420	rctx := &graphql.ResolverContext{
 7421		Object:   "SetTitleTimelineItem",
 7422		Field:    field,
 7423		Args:     nil,
 7424		IsMethod: false,
 7425	}
 7426	ctx = graphql.WithResolverContext(ctx, rctx)
 7427	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7428	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 7429		ctx = rctx // use context from middleware stack in children
 7430		return obj.Was, nil
 7431	})
 7432	if resTmp == nil {
 7433		if !ec.HasError(rctx) {
 7434			ec.Errorf(ctx, "must not be null")
 7435		}
 7436		return graphql.Null
 7437	}
 7438	res := resTmp.(string)
 7439	rctx.Result = res
 7440	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7441	return ec.marshalNString2string(ctx, field.Selections, res)
 7442}
 7443
 7444func (ec *executionContext) _TimelineItemConnection_edges(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) graphql.Marshaler {
 7445	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7446	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 7447	rctx := &graphql.ResolverContext{
 7448		Object:   "TimelineItemConnection",
 7449		Field:    field,
 7450		Args:     nil,
 7451		IsMethod: false,
 7452	}
 7453	ctx = graphql.WithResolverContext(ctx, rctx)
 7454	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7455	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 7456		ctx = rctx // use context from middleware stack in children
 7457		return obj.Edges, nil
 7458	})
 7459	if resTmp == nil {
 7460		if !ec.HasError(rctx) {
 7461			ec.Errorf(ctx, "must not be null")
 7462		}
 7463		return graphql.Null
 7464	}
 7465	res := resTmp.([]*models.TimelineItemEdge)
 7466	rctx.Result = res
 7467	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7468	return ec.marshalNTimelineItemEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx, field.Selections, res)
 7469}
 7470
 7471func (ec *executionContext) _TimelineItemConnection_nodes(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) graphql.Marshaler {
 7472	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7473	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 7474	rctx := &graphql.ResolverContext{
 7475		Object:   "TimelineItemConnection",
 7476		Field:    field,
 7477		Args:     nil,
 7478		IsMethod: false,
 7479	}
 7480	ctx = graphql.WithResolverContext(ctx, rctx)
 7481	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7482	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 7483		ctx = rctx // use context from middleware stack in children
 7484		return obj.Nodes, nil
 7485	})
 7486	if resTmp == nil {
 7487		if !ec.HasError(rctx) {
 7488			ec.Errorf(ctx, "must not be null")
 7489		}
 7490		return graphql.Null
 7491	}
 7492	res := resTmp.([]bug.TimelineItem)
 7493	rctx.Result = res
 7494	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7495	return ec.marshalNTimelineItem2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx, field.Selections, res)
 7496}
 7497
 7498func (ec *executionContext) _TimelineItemConnection_pageInfo(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) graphql.Marshaler {
 7499	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7500	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 7501	rctx := &graphql.ResolverContext{
 7502		Object:   "TimelineItemConnection",
 7503		Field:    field,
 7504		Args:     nil,
 7505		IsMethod: false,
 7506	}
 7507	ctx = graphql.WithResolverContext(ctx, rctx)
 7508	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7509	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 7510		ctx = rctx // use context from middleware stack in children
 7511		return obj.PageInfo, nil
 7512	})
 7513	if resTmp == nil {
 7514		if !ec.HasError(rctx) {
 7515			ec.Errorf(ctx, "must not be null")
 7516		}
 7517		return graphql.Null
 7518	}
 7519	res := resTmp.(*models.PageInfo)
 7520	rctx.Result = res
 7521	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7522	return ec.marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx, field.Selections, res)
 7523}
 7524
 7525func (ec *executionContext) _TimelineItemConnection_totalCount(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemConnection) graphql.Marshaler {
 7526	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7527	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 7528	rctx := &graphql.ResolverContext{
 7529		Object:   "TimelineItemConnection",
 7530		Field:    field,
 7531		Args:     nil,
 7532		IsMethod: false,
 7533	}
 7534	ctx = graphql.WithResolverContext(ctx, rctx)
 7535	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7536	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 7537		ctx = rctx // use context from middleware stack in children
 7538		return obj.TotalCount, nil
 7539	})
 7540	if resTmp == nil {
 7541		if !ec.HasError(rctx) {
 7542			ec.Errorf(ctx, "must not be null")
 7543		}
 7544		return graphql.Null
 7545	}
 7546	res := resTmp.(int)
 7547	rctx.Result = res
 7548	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7549	return ec.marshalNInt2int(ctx, field.Selections, res)
 7550}
 7551
 7552func (ec *executionContext) _TimelineItemEdge_cursor(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemEdge) graphql.Marshaler {
 7553	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7554	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 7555	rctx := &graphql.ResolverContext{
 7556		Object:   "TimelineItemEdge",
 7557		Field:    field,
 7558		Args:     nil,
 7559		IsMethod: false,
 7560	}
 7561	ctx = graphql.WithResolverContext(ctx, rctx)
 7562	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7563	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 7564		ctx = rctx // use context from middleware stack in children
 7565		return obj.Cursor, nil
 7566	})
 7567	if resTmp == nil {
 7568		if !ec.HasError(rctx) {
 7569			ec.Errorf(ctx, "must not be null")
 7570		}
 7571		return graphql.Null
 7572	}
 7573	res := resTmp.(string)
 7574	rctx.Result = res
 7575	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7576	return ec.marshalNString2string(ctx, field.Selections, res)
 7577}
 7578
 7579func (ec *executionContext) _TimelineItemEdge_node(ctx context.Context, field graphql.CollectedField, obj *models.TimelineItemEdge) graphql.Marshaler {
 7580	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7581	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 7582	rctx := &graphql.ResolverContext{
 7583		Object:   "TimelineItemEdge",
 7584		Field:    field,
 7585		Args:     nil,
 7586		IsMethod: false,
 7587	}
 7588	ctx = graphql.WithResolverContext(ctx, rctx)
 7589	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7590	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 7591		ctx = rctx // use context from middleware stack in children
 7592		return obj.Node, nil
 7593	})
 7594	if resTmp == nil {
 7595		if !ec.HasError(rctx) {
 7596			ec.Errorf(ctx, "must not be null")
 7597		}
 7598		return graphql.Null
 7599	}
 7600	res := resTmp.(bug.TimelineItem)
 7601	rctx.Result = res
 7602	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7603	return ec.marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx, field.Selections, res)
 7604}
 7605
 7606func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) graphql.Marshaler {
 7607	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7608	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 7609	rctx := &graphql.ResolverContext{
 7610		Object:   "__Directive",
 7611		Field:    field,
 7612		Args:     nil,
 7613		IsMethod: false,
 7614	}
 7615	ctx = graphql.WithResolverContext(ctx, rctx)
 7616	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7617	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 7618		ctx = rctx // use context from middleware stack in children
 7619		return obj.Name, nil
 7620	})
 7621	if resTmp == nil {
 7622		if !ec.HasError(rctx) {
 7623			ec.Errorf(ctx, "must not be null")
 7624		}
 7625		return graphql.Null
 7626	}
 7627	res := resTmp.(string)
 7628	rctx.Result = res
 7629	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7630	return ec.marshalNString2string(ctx, field.Selections, res)
 7631}
 7632
 7633func (ec *executionContext) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) graphql.Marshaler {
 7634	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7635	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 7636	rctx := &graphql.ResolverContext{
 7637		Object:   "__Directive",
 7638		Field:    field,
 7639		Args:     nil,
 7640		IsMethod: false,
 7641	}
 7642	ctx = graphql.WithResolverContext(ctx, rctx)
 7643	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7644	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 7645		ctx = rctx // use context from middleware stack in children
 7646		return obj.Description, nil
 7647	})
 7648	if resTmp == nil {
 7649		return graphql.Null
 7650	}
 7651	res := resTmp.(string)
 7652	rctx.Result = res
 7653	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7654	return ec.marshalOString2string(ctx, field.Selections, res)
 7655}
 7656
 7657func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) graphql.Marshaler {
 7658	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7659	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 7660	rctx := &graphql.ResolverContext{
 7661		Object:   "__Directive",
 7662		Field:    field,
 7663		Args:     nil,
 7664		IsMethod: false,
 7665	}
 7666	ctx = graphql.WithResolverContext(ctx, rctx)
 7667	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7668	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 7669		ctx = rctx // use context from middleware stack in children
 7670		return obj.Locations, nil
 7671	})
 7672	if resTmp == nil {
 7673		if !ec.HasError(rctx) {
 7674			ec.Errorf(ctx, "must not be null")
 7675		}
 7676		return graphql.Null
 7677	}
 7678	res := resTmp.([]string)
 7679	rctx.Result = res
 7680	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7681	return ec.marshalN__DirectiveLocation2ᚕstring(ctx, field.Selections, res)
 7682}
 7683
 7684func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) graphql.Marshaler {
 7685	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7686	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 7687	rctx := &graphql.ResolverContext{
 7688		Object:   "__Directive",
 7689		Field:    field,
 7690		Args:     nil,
 7691		IsMethod: false,
 7692	}
 7693	ctx = graphql.WithResolverContext(ctx, rctx)
 7694	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7695	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 7696		ctx = rctx // use context from middleware stack in children
 7697		return obj.Args, nil
 7698	})
 7699	if resTmp == nil {
 7700		if !ec.HasError(rctx) {
 7701			ec.Errorf(ctx, "must not be null")
 7702		}
 7703		return graphql.Null
 7704	}
 7705	res := resTmp.([]introspection.InputValue)
 7706	rctx.Result = res
 7707	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7708	return ec.marshalN__InputValue2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, field.Selections, res)
 7709}
 7710
 7711func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) graphql.Marshaler {
 7712	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7713	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 7714	rctx := &graphql.ResolverContext{
 7715		Object:   "__EnumValue",
 7716		Field:    field,
 7717		Args:     nil,
 7718		IsMethod: false,
 7719	}
 7720	ctx = graphql.WithResolverContext(ctx, rctx)
 7721	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7722	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 7723		ctx = rctx // use context from middleware stack in children
 7724		return obj.Name, nil
 7725	})
 7726	if resTmp == nil {
 7727		if !ec.HasError(rctx) {
 7728			ec.Errorf(ctx, "must not be null")
 7729		}
 7730		return graphql.Null
 7731	}
 7732	res := resTmp.(string)
 7733	rctx.Result = res
 7734	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7735	return ec.marshalNString2string(ctx, field.Selections, res)
 7736}
 7737
 7738func (ec *executionContext) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) graphql.Marshaler {
 7739	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7740	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 7741	rctx := &graphql.ResolverContext{
 7742		Object:   "__EnumValue",
 7743		Field:    field,
 7744		Args:     nil,
 7745		IsMethod: false,
 7746	}
 7747	ctx = graphql.WithResolverContext(ctx, rctx)
 7748	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7749	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 7750		ctx = rctx // use context from middleware stack in children
 7751		return obj.Description, nil
 7752	})
 7753	if resTmp == nil {
 7754		return graphql.Null
 7755	}
 7756	res := resTmp.(string)
 7757	rctx.Result = res
 7758	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7759	return ec.marshalOString2string(ctx, field.Selections, res)
 7760}
 7761
 7762func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) graphql.Marshaler {
 7763	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7764	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 7765	rctx := &graphql.ResolverContext{
 7766		Object:   "__EnumValue",
 7767		Field:    field,
 7768		Args:     nil,
 7769		IsMethod: true,
 7770	}
 7771	ctx = graphql.WithResolverContext(ctx, rctx)
 7772	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7773	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 7774		ctx = rctx // use context from middleware stack in children
 7775		return obj.IsDeprecated(), nil
 7776	})
 7777	if resTmp == nil {
 7778		if !ec.HasError(rctx) {
 7779			ec.Errorf(ctx, "must not be null")
 7780		}
 7781		return graphql.Null
 7782	}
 7783	res := resTmp.(bool)
 7784	rctx.Result = res
 7785	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7786	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 7787}
 7788
 7789func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) graphql.Marshaler {
 7790	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7791	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 7792	rctx := &graphql.ResolverContext{
 7793		Object:   "__EnumValue",
 7794		Field:    field,
 7795		Args:     nil,
 7796		IsMethod: true,
 7797	}
 7798	ctx = graphql.WithResolverContext(ctx, rctx)
 7799	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7800	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 7801		ctx = rctx // use context from middleware stack in children
 7802		return obj.DeprecationReason(), nil
 7803	})
 7804	if resTmp == nil {
 7805		return graphql.Null
 7806	}
 7807	res := resTmp.(*string)
 7808	rctx.Result = res
 7809	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7810	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 7811}
 7812
 7813func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) graphql.Marshaler {
 7814	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7815	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 7816	rctx := &graphql.ResolverContext{
 7817		Object:   "__Field",
 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 := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 7825		ctx = rctx // use context from middleware stack in children
 7826		return obj.Name, nil
 7827	})
 7828	if resTmp == nil {
 7829		if !ec.HasError(rctx) {
 7830			ec.Errorf(ctx, "must not be null")
 7831		}
 7832		return graphql.Null
 7833	}
 7834	res := resTmp.(string)
 7835	rctx.Result = res
 7836	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7837	return ec.marshalNString2string(ctx, field.Selections, res)
 7838}
 7839
 7840func (ec *executionContext) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) graphql.Marshaler {
 7841	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7842	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 7843	rctx := &graphql.ResolverContext{
 7844		Object:   "__Field",
 7845		Field:    field,
 7846		Args:     nil,
 7847		IsMethod: false,
 7848	}
 7849	ctx = graphql.WithResolverContext(ctx, rctx)
 7850	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7851	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 7852		ctx = rctx // use context from middleware stack in children
 7853		return obj.Description, nil
 7854	})
 7855	if resTmp == nil {
 7856		return graphql.Null
 7857	}
 7858	res := resTmp.(string)
 7859	rctx.Result = res
 7860	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7861	return ec.marshalOString2string(ctx, field.Selections, res)
 7862}
 7863
 7864func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) graphql.Marshaler {
 7865	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7866	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 7867	rctx := &graphql.ResolverContext{
 7868		Object:   "__Field",
 7869		Field:    field,
 7870		Args:     nil,
 7871		IsMethod: false,
 7872	}
 7873	ctx = graphql.WithResolverContext(ctx, rctx)
 7874	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7875	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 7876		ctx = rctx // use context from middleware stack in children
 7877		return obj.Args, nil
 7878	})
 7879	if resTmp == nil {
 7880		if !ec.HasError(rctx) {
 7881			ec.Errorf(ctx, "must not be null")
 7882		}
 7883		return graphql.Null
 7884	}
 7885	res := resTmp.([]introspection.InputValue)
 7886	rctx.Result = res
 7887	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7888	return ec.marshalN__InputValue2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, field.Selections, res)
 7889}
 7890
 7891func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) graphql.Marshaler {
 7892	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7893	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 7894	rctx := &graphql.ResolverContext{
 7895		Object:   "__Field",
 7896		Field:    field,
 7897		Args:     nil,
 7898		IsMethod: false,
 7899	}
 7900	ctx = graphql.WithResolverContext(ctx, rctx)
 7901	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7902	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 7903		ctx = rctx // use context from middleware stack in children
 7904		return obj.Type, nil
 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.(*introspection.Type)
 7913	rctx.Result = res
 7914	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7915	return ec.marshalN__Type2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
 7916}
 7917
 7918func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) graphql.Marshaler {
 7919	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7920	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 7921	rctx := &graphql.ResolverContext{
 7922		Object:   "__Field",
 7923		Field:    field,
 7924		Args:     nil,
 7925		IsMethod: true,
 7926	}
 7927	ctx = graphql.WithResolverContext(ctx, rctx)
 7928	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7929	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 7930		ctx = rctx // use context from middleware stack in children
 7931		return obj.IsDeprecated(), nil
 7932	})
 7933	if resTmp == nil {
 7934		if !ec.HasError(rctx) {
 7935			ec.Errorf(ctx, "must not be null")
 7936		}
 7937		return graphql.Null
 7938	}
 7939	res := resTmp.(bool)
 7940	rctx.Result = res
 7941	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7942	return ec.marshalNBoolean2bool(ctx, field.Selections, res)
 7943}
 7944
 7945func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) graphql.Marshaler {
 7946	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7947	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 7948	rctx := &graphql.ResolverContext{
 7949		Object:   "__Field",
 7950		Field:    field,
 7951		Args:     nil,
 7952		IsMethod: true,
 7953	}
 7954	ctx = graphql.WithResolverContext(ctx, rctx)
 7955	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7956	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 7957		ctx = rctx // use context from middleware stack in children
 7958		return obj.DeprecationReason(), nil
 7959	})
 7960	if resTmp == nil {
 7961		return graphql.Null
 7962	}
 7963	res := resTmp.(*string)
 7964	rctx.Result = res
 7965	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7966	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 7967}
 7968
 7969func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) graphql.Marshaler {
 7970	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7971	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 7972	rctx := &graphql.ResolverContext{
 7973		Object:   "__InputValue",
 7974		Field:    field,
 7975		Args:     nil,
 7976		IsMethod: false,
 7977	}
 7978	ctx = graphql.WithResolverContext(ctx, rctx)
 7979	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 7980	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 7981		ctx = rctx // use context from middleware stack in children
 7982		return obj.Name, nil
 7983	})
 7984	if resTmp == nil {
 7985		if !ec.HasError(rctx) {
 7986			ec.Errorf(ctx, "must not be null")
 7987		}
 7988		return graphql.Null
 7989	}
 7990	res := resTmp.(string)
 7991	rctx.Result = res
 7992	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 7993	return ec.marshalNString2string(ctx, field.Selections, res)
 7994}
 7995
 7996func (ec *executionContext) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) graphql.Marshaler {
 7997	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 7998	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 7999	rctx := &graphql.ResolverContext{
 8000		Object:   "__InputValue",
 8001		Field:    field,
 8002		Args:     nil,
 8003		IsMethod: false,
 8004	}
 8005	ctx = graphql.WithResolverContext(ctx, rctx)
 8006	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 8007	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 8008		ctx = rctx // use context from middleware stack in children
 8009		return obj.Description, nil
 8010	})
 8011	if resTmp == nil {
 8012		return graphql.Null
 8013	}
 8014	res := resTmp.(string)
 8015	rctx.Result = res
 8016	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 8017	return ec.marshalOString2string(ctx, field.Selections, res)
 8018}
 8019
 8020func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) graphql.Marshaler {
 8021	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 8022	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 8023	rctx := &graphql.ResolverContext{
 8024		Object:   "__InputValue",
 8025		Field:    field,
 8026		Args:     nil,
 8027		IsMethod: false,
 8028	}
 8029	ctx = graphql.WithResolverContext(ctx, rctx)
 8030	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 8031	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 8032		ctx = rctx // use context from middleware stack in children
 8033		return obj.Type, nil
 8034	})
 8035	if resTmp == nil {
 8036		if !ec.HasError(rctx) {
 8037			ec.Errorf(ctx, "must not be null")
 8038		}
 8039		return graphql.Null
 8040	}
 8041	res := resTmp.(*introspection.Type)
 8042	rctx.Result = res
 8043	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 8044	return ec.marshalN__Type2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
 8045}
 8046
 8047func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) graphql.Marshaler {
 8048	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 8049	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 8050	rctx := &graphql.ResolverContext{
 8051		Object:   "__InputValue",
 8052		Field:    field,
 8053		Args:     nil,
 8054		IsMethod: false,
 8055	}
 8056	ctx = graphql.WithResolverContext(ctx, rctx)
 8057	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 8058	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 8059		ctx = rctx // use context from middleware stack in children
 8060		return obj.DefaultValue, nil
 8061	})
 8062	if resTmp == nil {
 8063		return graphql.Null
 8064	}
 8065	res := resTmp.(*string)
 8066	rctx.Result = res
 8067	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 8068	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 8069}
 8070
 8071func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) graphql.Marshaler {
 8072	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 8073	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 8074	rctx := &graphql.ResolverContext{
 8075		Object:   "__Schema",
 8076		Field:    field,
 8077		Args:     nil,
 8078		IsMethod: true,
 8079	}
 8080	ctx = graphql.WithResolverContext(ctx, rctx)
 8081	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 8082	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 8083		ctx = rctx // use context from middleware stack in children
 8084		return obj.Types(), nil
 8085	})
 8086	if resTmp == nil {
 8087		if !ec.HasError(rctx) {
 8088			ec.Errorf(ctx, "must not be null")
 8089		}
 8090		return graphql.Null
 8091	}
 8092	res := resTmp.([]introspection.Type)
 8093	rctx.Result = res
 8094	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 8095	return ec.marshalN__Type2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
 8096}
 8097
 8098func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) graphql.Marshaler {
 8099	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 8100	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 8101	rctx := &graphql.ResolverContext{
 8102		Object:   "__Schema",
 8103		Field:    field,
 8104		Args:     nil,
 8105		IsMethod: true,
 8106	}
 8107	ctx = graphql.WithResolverContext(ctx, rctx)
 8108	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 8109	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 8110		ctx = rctx // use context from middleware stack in children
 8111		return obj.QueryType(), nil
 8112	})
 8113	if resTmp == nil {
 8114		if !ec.HasError(rctx) {
 8115			ec.Errorf(ctx, "must not be null")
 8116		}
 8117		return graphql.Null
 8118	}
 8119	res := resTmp.(*introspection.Type)
 8120	rctx.Result = res
 8121	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 8122	return ec.marshalN__Type2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
 8123}
 8124
 8125func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) graphql.Marshaler {
 8126	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 8127	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 8128	rctx := &graphql.ResolverContext{
 8129		Object:   "__Schema",
 8130		Field:    field,
 8131		Args:     nil,
 8132		IsMethod: true,
 8133	}
 8134	ctx = graphql.WithResolverContext(ctx, rctx)
 8135	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 8136	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 8137		ctx = rctx // use context from middleware stack in children
 8138		return obj.MutationType(), nil
 8139	})
 8140	if resTmp == nil {
 8141		return graphql.Null
 8142	}
 8143	res := resTmp.(*introspection.Type)
 8144	rctx.Result = res
 8145	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 8146	return ec.marshalO__Type2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
 8147}
 8148
 8149func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) graphql.Marshaler {
 8150	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 8151	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 8152	rctx := &graphql.ResolverContext{
 8153		Object:   "__Schema",
 8154		Field:    field,
 8155		Args:     nil,
 8156		IsMethod: true,
 8157	}
 8158	ctx = graphql.WithResolverContext(ctx, rctx)
 8159	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 8160	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 8161		ctx = rctx // use context from middleware stack in children
 8162		return obj.SubscriptionType(), nil
 8163	})
 8164	if resTmp == nil {
 8165		return graphql.Null
 8166	}
 8167	res := resTmp.(*introspection.Type)
 8168	rctx.Result = res
 8169	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 8170	return ec.marshalO__Type2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
 8171}
 8172
 8173func (ec *executionContext) ___Schema_directives(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) graphql.Marshaler {
 8174	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 8175	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 8176	rctx := &graphql.ResolverContext{
 8177		Object:   "__Schema",
 8178		Field:    field,
 8179		Args:     nil,
 8180		IsMethod: true,
 8181	}
 8182	ctx = graphql.WithResolverContext(ctx, rctx)
 8183	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 8184	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 8185		ctx = rctx // use context from middleware stack in children
 8186		return obj.Directives(), nil
 8187	})
 8188	if resTmp == nil {
 8189		if !ec.HasError(rctx) {
 8190			ec.Errorf(ctx, "must not be null")
 8191		}
 8192		return graphql.Null
 8193	}
 8194	res := resTmp.([]introspection.Directive)
 8195	rctx.Result = res
 8196	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 8197	return ec.marshalN__Directive2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx, field.Selections, res)
 8198}
 8199
 8200func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler {
 8201	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 8202	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 8203	rctx := &graphql.ResolverContext{
 8204		Object:   "__Type",
 8205		Field:    field,
 8206		Args:     nil,
 8207		IsMethod: true,
 8208	}
 8209	ctx = graphql.WithResolverContext(ctx, rctx)
 8210	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 8211	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 8212		ctx = rctx // use context from middleware stack in children
 8213		return obj.Kind(), nil
 8214	})
 8215	if resTmp == nil {
 8216		if !ec.HasError(rctx) {
 8217			ec.Errorf(ctx, "must not be null")
 8218		}
 8219		return graphql.Null
 8220	}
 8221	res := resTmp.(string)
 8222	rctx.Result = res
 8223	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 8224	return ec.marshalN__TypeKind2string(ctx, field.Selections, res)
 8225}
 8226
 8227func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler {
 8228	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 8229	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 8230	rctx := &graphql.ResolverContext{
 8231		Object:   "__Type",
 8232		Field:    field,
 8233		Args:     nil,
 8234		IsMethod: true,
 8235	}
 8236	ctx = graphql.WithResolverContext(ctx, rctx)
 8237	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 8238	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 8239		ctx = rctx // use context from middleware stack in children
 8240		return obj.Name(), nil
 8241	})
 8242	if resTmp == nil {
 8243		return graphql.Null
 8244	}
 8245	res := resTmp.(*string)
 8246	rctx.Result = res
 8247	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 8248	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
 8249}
 8250
 8251func (ec *executionContext) ___Type_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler {
 8252	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 8253	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 8254	rctx := &graphql.ResolverContext{
 8255		Object:   "__Type",
 8256		Field:    field,
 8257		Args:     nil,
 8258		IsMethod: true,
 8259	}
 8260	ctx = graphql.WithResolverContext(ctx, rctx)
 8261	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 8262	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 8263		ctx = rctx // use context from middleware stack in children
 8264		return obj.Description(), nil
 8265	})
 8266	if resTmp == nil {
 8267		return graphql.Null
 8268	}
 8269	res := resTmp.(string)
 8270	rctx.Result = res
 8271	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 8272	return ec.marshalOString2string(ctx, field.Selections, res)
 8273}
 8274
 8275func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler {
 8276	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 8277	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 8278	rctx := &graphql.ResolverContext{
 8279		Object:   "__Type",
 8280		Field:    field,
 8281		Args:     nil,
 8282		IsMethod: true,
 8283	}
 8284	ctx = graphql.WithResolverContext(ctx, rctx)
 8285	rawArgs := field.ArgumentMap(ec.Variables)
 8286	args, err := ec.field___Type_fields_args(ctx, rawArgs)
 8287	if err != nil {
 8288		ec.Error(ctx, err)
 8289		return graphql.Null
 8290	}
 8291	rctx.Args = args
 8292	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 8293	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 8294		ctx = rctx // use context from middleware stack in children
 8295		return obj.Fields(args["includeDeprecated"].(bool)), nil
 8296	})
 8297	if resTmp == nil {
 8298		return graphql.Null
 8299	}
 8300	res := resTmp.([]introspection.Field)
 8301	rctx.Result = res
 8302	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 8303	return ec.marshalO__Field2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx, field.Selections, res)
 8304}
 8305
 8306func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler {
 8307	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 8308	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 8309	rctx := &graphql.ResolverContext{
 8310		Object:   "__Type",
 8311		Field:    field,
 8312		Args:     nil,
 8313		IsMethod: true,
 8314	}
 8315	ctx = graphql.WithResolverContext(ctx, rctx)
 8316	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 8317	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 8318		ctx = rctx // use context from middleware stack in children
 8319		return obj.Interfaces(), nil
 8320	})
 8321	if resTmp == nil {
 8322		return graphql.Null
 8323	}
 8324	res := resTmp.([]introspection.Type)
 8325	rctx.Result = res
 8326	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 8327	return ec.marshalO__Type2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
 8328}
 8329
 8330func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler {
 8331	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 8332	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 8333	rctx := &graphql.ResolverContext{
 8334		Object:   "__Type",
 8335		Field:    field,
 8336		Args:     nil,
 8337		IsMethod: true,
 8338	}
 8339	ctx = graphql.WithResolverContext(ctx, rctx)
 8340	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 8341	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 8342		ctx = rctx // use context from middleware stack in children
 8343		return obj.PossibleTypes(), nil
 8344	})
 8345	if resTmp == nil {
 8346		return graphql.Null
 8347	}
 8348	res := resTmp.([]introspection.Type)
 8349	rctx.Result = res
 8350	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 8351	return ec.marshalO__Type2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
 8352}
 8353
 8354func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler {
 8355	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 8356	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 8357	rctx := &graphql.ResolverContext{
 8358		Object:   "__Type",
 8359		Field:    field,
 8360		Args:     nil,
 8361		IsMethod: true,
 8362	}
 8363	ctx = graphql.WithResolverContext(ctx, rctx)
 8364	rawArgs := field.ArgumentMap(ec.Variables)
 8365	args, err := ec.field___Type_enumValues_args(ctx, rawArgs)
 8366	if err != nil {
 8367		ec.Error(ctx, err)
 8368		return graphql.Null
 8369	}
 8370	rctx.Args = args
 8371	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 8372	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 8373		ctx = rctx // use context from middleware stack in children
 8374		return obj.EnumValues(args["includeDeprecated"].(bool)), nil
 8375	})
 8376	if resTmp == nil {
 8377		return graphql.Null
 8378	}
 8379	res := resTmp.([]introspection.EnumValue)
 8380	rctx.Result = res
 8381	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 8382	return ec.marshalO__EnumValue2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx, field.Selections, res)
 8383}
 8384
 8385func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler {
 8386	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 8387	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 8388	rctx := &graphql.ResolverContext{
 8389		Object:   "__Type",
 8390		Field:    field,
 8391		Args:     nil,
 8392		IsMethod: true,
 8393	}
 8394	ctx = graphql.WithResolverContext(ctx, rctx)
 8395	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 8396	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 8397		ctx = rctx // use context from middleware stack in children
 8398		return obj.InputFields(), nil
 8399	})
 8400	if resTmp == nil {
 8401		return graphql.Null
 8402	}
 8403	res := resTmp.([]introspection.InputValue)
 8404	rctx.Result = res
 8405	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 8406	return ec.marshalO__InputValue2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, field.Selections, res)
 8407}
 8408
 8409func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) graphql.Marshaler {
 8410	ctx = ec.Tracer.StartFieldExecution(ctx, field)
 8411	defer func() { ec.Tracer.EndFieldExecution(ctx) }()
 8412	rctx := &graphql.ResolverContext{
 8413		Object:   "__Type",
 8414		Field:    field,
 8415		Args:     nil,
 8416		IsMethod: true,
 8417	}
 8418	ctx = graphql.WithResolverContext(ctx, rctx)
 8419	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)
 8420	resTmp := ec.FieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) {
 8421		ctx = rctx // use context from middleware stack in children
 8422		return obj.OfType(), nil
 8423	})
 8424	if resTmp == nil {
 8425		return graphql.Null
 8426	}
 8427	res := resTmp.(*introspection.Type)
 8428	rctx.Result = res
 8429	ctx = ec.Tracer.StartFieldChildExecution(ctx)
 8430	return ec.marshalO__Type2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
 8431}
 8432
 8433// endregion **************************** field.gotpl *****************************
 8434
 8435// region    **************************** input.gotpl *****************************
 8436
 8437func (ec *executionContext) unmarshalInputAddCommentInput(ctx context.Context, v interface{}) (models.AddCommentInput, error) {
 8438	var it models.AddCommentInput
 8439	var asMap = v.(map[string]interface{})
 8440
 8441	for k, v := range asMap {
 8442		switch k {
 8443		case "clientMutationId":
 8444			var err error
 8445			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
 8446			if err != nil {
 8447				return it, err
 8448			}
 8449		case "repoRef":
 8450			var err error
 8451			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
 8452			if err != nil {
 8453				return it, err
 8454			}
 8455		case "prefix":
 8456			var err error
 8457			it.Prefix, err = ec.unmarshalNString2string(ctx, v)
 8458			if err != nil {
 8459				return it, err
 8460			}
 8461		case "message":
 8462			var err error
 8463			it.Message, err = ec.unmarshalNString2string(ctx, v)
 8464			if err != nil {
 8465				return it, err
 8466			}
 8467		case "files":
 8468			var err error
 8469			it.Files, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, v)
 8470			if err != nil {
 8471				return it, err
 8472			}
 8473		}
 8474	}
 8475
 8476	return it, nil
 8477}
 8478
 8479func (ec *executionContext) unmarshalInputChangeLabelInput(ctx context.Context, v interface{}) (models.ChangeLabelInput, error) {
 8480	var it models.ChangeLabelInput
 8481	var asMap = v.(map[string]interface{})
 8482
 8483	for k, v := range asMap {
 8484		switch k {
 8485		case "clientMutationId":
 8486			var err error
 8487			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
 8488			if err != nil {
 8489				return it, err
 8490			}
 8491		case "repoRef":
 8492			var err error
 8493			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
 8494			if err != nil {
 8495				return it, err
 8496			}
 8497		case "prefix":
 8498			var err error
 8499			it.Prefix, err = ec.unmarshalNString2string(ctx, v)
 8500			if err != nil {
 8501				return it, err
 8502			}
 8503		case "added":
 8504			var err error
 8505			it.Added, err = ec.unmarshalOString2ᚕstring(ctx, v)
 8506			if err != nil {
 8507				return it, err
 8508			}
 8509		case "Removed":
 8510			var err error
 8511			it.Removed, err = ec.unmarshalOString2ᚕstring(ctx, v)
 8512			if err != nil {
 8513				return it, err
 8514			}
 8515		}
 8516	}
 8517
 8518	return it, nil
 8519}
 8520
 8521func (ec *executionContext) unmarshalInputCloseBugInput(ctx context.Context, v interface{}) (models.CloseBugInput, error) {
 8522	var it models.CloseBugInput
 8523	var asMap = v.(map[string]interface{})
 8524
 8525	for k, v := range asMap {
 8526		switch k {
 8527		case "clientMutationId":
 8528			var err error
 8529			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
 8530			if err != nil {
 8531				return it, err
 8532			}
 8533		case "repoRef":
 8534			var err error
 8535			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
 8536			if err != nil {
 8537				return it, err
 8538			}
 8539		case "prefix":
 8540			var err error
 8541			it.Prefix, err = ec.unmarshalNString2string(ctx, v)
 8542			if err != nil {
 8543				return it, err
 8544			}
 8545		}
 8546	}
 8547
 8548	return it, nil
 8549}
 8550
 8551func (ec *executionContext) unmarshalInputCommitAsNeededInput(ctx context.Context, v interface{}) (models.CommitAsNeededInput, error) {
 8552	var it models.CommitAsNeededInput
 8553	var asMap = v.(map[string]interface{})
 8554
 8555	for k, v := range asMap {
 8556		switch k {
 8557		case "clientMutationId":
 8558			var err error
 8559			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
 8560			if err != nil {
 8561				return it, err
 8562			}
 8563		case "repoRef":
 8564			var err error
 8565			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
 8566			if err != nil {
 8567				return it, err
 8568			}
 8569		case "prefix":
 8570			var err error
 8571			it.Prefix, err = ec.unmarshalNString2string(ctx, v)
 8572			if err != nil {
 8573				return it, err
 8574			}
 8575		}
 8576	}
 8577
 8578	return it, nil
 8579}
 8580
 8581func (ec *executionContext) unmarshalInputCommitInput(ctx context.Context, v interface{}) (models.CommitInput, error) {
 8582	var it models.CommitInput
 8583	var asMap = v.(map[string]interface{})
 8584
 8585	for k, v := range asMap {
 8586		switch k {
 8587		case "clientMutationId":
 8588			var err error
 8589			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
 8590			if err != nil {
 8591				return it, err
 8592			}
 8593		case "repoRef":
 8594			var err error
 8595			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
 8596			if err != nil {
 8597				return it, err
 8598			}
 8599		case "prefix":
 8600			var err error
 8601			it.Prefix, err = ec.unmarshalNString2string(ctx, v)
 8602			if err != nil {
 8603				return it, err
 8604			}
 8605		}
 8606	}
 8607
 8608	return it, nil
 8609}
 8610
 8611func (ec *executionContext) unmarshalInputNewBugInput(ctx context.Context, v interface{}) (models.NewBugInput, error) {
 8612	var it models.NewBugInput
 8613	var asMap = v.(map[string]interface{})
 8614
 8615	for k, v := range asMap {
 8616		switch k {
 8617		case "clientMutationId":
 8618			var err error
 8619			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
 8620			if err != nil {
 8621				return it, err
 8622			}
 8623		case "repoRef":
 8624			var err error
 8625			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
 8626			if err != nil {
 8627				return it, err
 8628			}
 8629		case "title":
 8630			var err error
 8631			it.Title, err = ec.unmarshalNString2string(ctx, v)
 8632			if err != nil {
 8633				return it, err
 8634			}
 8635		case "message":
 8636			var err error
 8637			it.Message, err = ec.unmarshalNString2string(ctx, v)
 8638			if err != nil {
 8639				return it, err
 8640			}
 8641		case "files":
 8642			var err error
 8643			it.Files, err = ec.unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, v)
 8644			if err != nil {
 8645				return it, err
 8646			}
 8647		}
 8648	}
 8649
 8650	return it, nil
 8651}
 8652
 8653func (ec *executionContext) unmarshalInputOpenBugInput(ctx context.Context, v interface{}) (models.OpenBugInput, error) {
 8654	var it models.OpenBugInput
 8655	var asMap = v.(map[string]interface{})
 8656
 8657	for k, v := range asMap {
 8658		switch k {
 8659		case "clientMutationId":
 8660			var err error
 8661			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
 8662			if err != nil {
 8663				return it, err
 8664			}
 8665		case "repoRef":
 8666			var err error
 8667			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
 8668			if err != nil {
 8669				return it, err
 8670			}
 8671		case "prefix":
 8672			var err error
 8673			it.Prefix, err = ec.unmarshalNString2string(ctx, v)
 8674			if err != nil {
 8675				return it, err
 8676			}
 8677		}
 8678	}
 8679
 8680	return it, nil
 8681}
 8682
 8683func (ec *executionContext) unmarshalInputSetTitleInput(ctx context.Context, v interface{}) (models.SetTitleInput, error) {
 8684	var it models.SetTitleInput
 8685	var asMap = v.(map[string]interface{})
 8686
 8687	for k, v := range asMap {
 8688		switch k {
 8689		case "clientMutationId":
 8690			var err error
 8691			it.ClientMutationID, err = ec.unmarshalOString2ᚖstring(ctx, v)
 8692			if err != nil {
 8693				return it, err
 8694			}
 8695		case "repoRef":
 8696			var err error
 8697			it.RepoRef, err = ec.unmarshalOString2ᚖstring(ctx, v)
 8698			if err != nil {
 8699				return it, err
 8700			}
 8701		case "prefix":
 8702			var err error
 8703			it.Prefix, err = ec.unmarshalNString2string(ctx, v)
 8704			if err != nil {
 8705				return it, err
 8706			}
 8707		case "title":
 8708			var err error
 8709			it.Title, err = ec.unmarshalNString2string(ctx, v)
 8710			if err != nil {
 8711				return it, err
 8712			}
 8713		}
 8714	}
 8715
 8716	return it, nil
 8717}
 8718
 8719// endregion **************************** input.gotpl *****************************
 8720
 8721// region    ************************** interface.gotpl ***************************
 8722
 8723func (ec *executionContext) _Authored(ctx context.Context, sel ast.SelectionSet, obj *models.Authored) graphql.Marshaler {
 8724	switch obj := (*obj).(type) {
 8725	case nil:
 8726		return graphql.Null
 8727	case bug.Comment:
 8728		return ec._Comment(ctx, sel, &obj)
 8729	case *bug.Comment:
 8730		return ec._Comment(ctx, sel, obj)
 8731	case *bug.Snapshot:
 8732		return ec._Bug(ctx, sel, obj)
 8733	case *bug.CreateOperation:
 8734		return ec._CreateOperation(ctx, sel, obj)
 8735	case *bug.SetTitleOperation:
 8736		return ec._SetTitleOperation(ctx, sel, obj)
 8737	case *bug.AddCommentOperation:
 8738		return ec._AddCommentOperation(ctx, sel, obj)
 8739	case *bug.EditCommentOperation:
 8740		return ec._EditCommentOperation(ctx, sel, obj)
 8741	case *bug.SetStatusOperation:
 8742		return ec._SetStatusOperation(ctx, sel, obj)
 8743	case *bug.LabelChangeOperation:
 8744		return ec._LabelChangeOperation(ctx, sel, obj)
 8745	case *bug.CreateTimelineItem:
 8746		return ec._CreateTimelineItem(ctx, sel, obj)
 8747	case *bug.AddCommentTimelineItem:
 8748		return ec._AddCommentTimelineItem(ctx, sel, obj)
 8749	case *bug.LabelChangeTimelineItem:
 8750		return ec._LabelChangeTimelineItem(ctx, sel, obj)
 8751	case *bug.SetStatusTimelineItem:
 8752		return ec._SetStatusTimelineItem(ctx, sel, obj)
 8753	case *bug.SetTitleTimelineItem:
 8754		return ec._SetTitleTimelineItem(ctx, sel, obj)
 8755	default:
 8756		panic(fmt.Errorf("unexpected type %T", obj))
 8757	}
 8758}
 8759
 8760func (ec *executionContext) _Operation(ctx context.Context, sel ast.SelectionSet, obj *bug.Operation) graphql.Marshaler {
 8761	switch obj := (*obj).(type) {
 8762	case nil:
 8763		return graphql.Null
 8764	case *bug.CreateOperation:
 8765		return ec._CreateOperation(ctx, sel, obj)
 8766	case *bug.SetTitleOperation:
 8767		return ec._SetTitleOperation(ctx, sel, obj)
 8768	case *bug.AddCommentOperation:
 8769		return ec._AddCommentOperation(ctx, sel, obj)
 8770	case *bug.EditCommentOperation:
 8771		return ec._EditCommentOperation(ctx, sel, obj)
 8772	case *bug.SetStatusOperation:
 8773		return ec._SetStatusOperation(ctx, sel, obj)
 8774	case *bug.LabelChangeOperation:
 8775		return ec._LabelChangeOperation(ctx, sel, obj)
 8776	default:
 8777		panic(fmt.Errorf("unexpected type %T", obj))
 8778	}
 8779}
 8780
 8781func (ec *executionContext) _TimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.TimelineItem) graphql.Marshaler {
 8782	switch obj := (*obj).(type) {
 8783	case nil:
 8784		return graphql.Null
 8785	case *bug.CreateTimelineItem:
 8786		return ec._CreateTimelineItem(ctx, sel, obj)
 8787	case *bug.AddCommentTimelineItem:
 8788		return ec._AddCommentTimelineItem(ctx, sel, obj)
 8789	case bug.LabelChangeTimelineItem:
 8790		return ec._LabelChangeTimelineItem(ctx, sel, &obj)
 8791	case *bug.LabelChangeTimelineItem:
 8792		return ec._LabelChangeTimelineItem(ctx, sel, obj)
 8793	case bug.SetStatusTimelineItem:
 8794		return ec._SetStatusTimelineItem(ctx, sel, &obj)
 8795	case *bug.SetStatusTimelineItem:
 8796		return ec._SetStatusTimelineItem(ctx, sel, obj)
 8797	case bug.SetTitleTimelineItem:
 8798		return ec._SetTitleTimelineItem(ctx, sel, &obj)
 8799	case *bug.SetTitleTimelineItem:
 8800		return ec._SetTitleTimelineItem(ctx, sel, obj)
 8801	default:
 8802		panic(fmt.Errorf("unexpected type %T", obj))
 8803	}
 8804}
 8805
 8806// endregion ************************** interface.gotpl ***************************
 8807
 8808// region    **************************** object.gotpl ****************************
 8809
 8810var addCommentOperationImplementors = []string{"AddCommentOperation", "Operation", "Authored"}
 8811
 8812func (ec *executionContext) _AddCommentOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.AddCommentOperation) graphql.Marshaler {
 8813	fields := graphql.CollectFields(ec.RequestContext, sel, addCommentOperationImplementors)
 8814
 8815	out := graphql.NewFieldSet(fields)
 8816	var invalids uint32
 8817	for i, field := range fields {
 8818		switch field.Name {
 8819		case "__typename":
 8820			out.Values[i] = graphql.MarshalString("AddCommentOperation")
 8821		case "hash":
 8822			out.Values[i] = ec._AddCommentOperation_hash(ctx, field, obj)
 8823			if out.Values[i] == graphql.Null {
 8824				atomic.AddUint32(&invalids, 1)
 8825			}
 8826		case "author":
 8827			out.Values[i] = ec._AddCommentOperation_author(ctx, field, obj)
 8828			if out.Values[i] == graphql.Null {
 8829				atomic.AddUint32(&invalids, 1)
 8830			}
 8831		case "date":
 8832			field := field
 8833			out.Concurrently(i, func() (res graphql.Marshaler) {
 8834				defer func() {
 8835					if r := recover(); r != nil {
 8836						ec.Error(ctx, ec.Recover(ctx, r))
 8837					}
 8838				}()
 8839				res = ec._AddCommentOperation_date(ctx, field, obj)
 8840				if res == graphql.Null {
 8841					atomic.AddUint32(&invalids, 1)
 8842				}
 8843				return res
 8844			})
 8845		case "message":
 8846			out.Values[i] = ec._AddCommentOperation_message(ctx, field, obj)
 8847			if out.Values[i] == graphql.Null {
 8848				atomic.AddUint32(&invalids, 1)
 8849			}
 8850		case "files":
 8851			out.Values[i] = ec._AddCommentOperation_files(ctx, field, obj)
 8852			if out.Values[i] == graphql.Null {
 8853				atomic.AddUint32(&invalids, 1)
 8854			}
 8855		default:
 8856			panic("unknown field " + strconv.Quote(field.Name))
 8857		}
 8858	}
 8859	out.Dispatch()
 8860	if invalids > 0 {
 8861		return graphql.Null
 8862	}
 8863	return out
 8864}
 8865
 8866var addCommentPayloadImplementors = []string{"AddCommentPayload"}
 8867
 8868func (ec *executionContext) _AddCommentPayload(ctx context.Context, sel ast.SelectionSet, obj *models.AddCommentPayload) graphql.Marshaler {
 8869	fields := graphql.CollectFields(ec.RequestContext, sel, addCommentPayloadImplementors)
 8870
 8871	out := graphql.NewFieldSet(fields)
 8872	var invalids uint32
 8873	for i, field := range fields {
 8874		switch field.Name {
 8875		case "__typename":
 8876			out.Values[i] = graphql.MarshalString("AddCommentPayload")
 8877		case "clientMutationId":
 8878			out.Values[i] = ec._AddCommentPayload_clientMutationId(ctx, field, obj)
 8879		case "bug":
 8880			out.Values[i] = ec._AddCommentPayload_bug(ctx, field, obj)
 8881			if out.Values[i] == graphql.Null {
 8882				invalids++
 8883			}
 8884		case "operation":
 8885			out.Values[i] = ec._AddCommentPayload_operation(ctx, field, obj)
 8886			if out.Values[i] == graphql.Null {
 8887				invalids++
 8888			}
 8889		default:
 8890			panic("unknown field " + strconv.Quote(field.Name))
 8891		}
 8892	}
 8893	out.Dispatch()
 8894	if invalids > 0 {
 8895		return graphql.Null
 8896	}
 8897	return out
 8898}
 8899
 8900var addCommentTimelineItemImplementors = []string{"AddCommentTimelineItem", "TimelineItem", "Authored"}
 8901
 8902func (ec *executionContext) _AddCommentTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.AddCommentTimelineItem) graphql.Marshaler {
 8903	fields := graphql.CollectFields(ec.RequestContext, sel, addCommentTimelineItemImplementors)
 8904
 8905	out := graphql.NewFieldSet(fields)
 8906	var invalids uint32
 8907	for i, field := range fields {
 8908		switch field.Name {
 8909		case "__typename":
 8910			out.Values[i] = graphql.MarshalString("AddCommentTimelineItem")
 8911		case "hash":
 8912			out.Values[i] = ec._AddCommentTimelineItem_hash(ctx, field, obj)
 8913			if out.Values[i] == graphql.Null {
 8914				atomic.AddUint32(&invalids, 1)
 8915			}
 8916		case "author":
 8917			out.Values[i] = ec._AddCommentTimelineItem_author(ctx, field, obj)
 8918			if out.Values[i] == graphql.Null {
 8919				atomic.AddUint32(&invalids, 1)
 8920			}
 8921		case "message":
 8922			out.Values[i] = ec._AddCommentTimelineItem_message(ctx, field, obj)
 8923			if out.Values[i] == graphql.Null {
 8924				atomic.AddUint32(&invalids, 1)
 8925			}
 8926		case "messageIsEmpty":
 8927			out.Values[i] = ec._AddCommentTimelineItem_messageIsEmpty(ctx, field, obj)
 8928			if out.Values[i] == graphql.Null {
 8929				atomic.AddUint32(&invalids, 1)
 8930			}
 8931		case "files":
 8932			out.Values[i] = ec._AddCommentTimelineItem_files(ctx, field, obj)
 8933			if out.Values[i] == graphql.Null {
 8934				atomic.AddUint32(&invalids, 1)
 8935			}
 8936		case "createdAt":
 8937			field := field
 8938			out.Concurrently(i, func() (res graphql.Marshaler) {
 8939				defer func() {
 8940					if r := recover(); r != nil {
 8941						ec.Error(ctx, ec.Recover(ctx, r))
 8942					}
 8943				}()
 8944				res = ec._AddCommentTimelineItem_createdAt(ctx, field, obj)
 8945				if res == graphql.Null {
 8946					atomic.AddUint32(&invalids, 1)
 8947				}
 8948				return res
 8949			})
 8950		case "lastEdit":
 8951			field := field
 8952			out.Concurrently(i, func() (res graphql.Marshaler) {
 8953				defer func() {
 8954					if r := recover(); r != nil {
 8955						ec.Error(ctx, ec.Recover(ctx, r))
 8956					}
 8957				}()
 8958				res = ec._AddCommentTimelineItem_lastEdit(ctx, field, obj)
 8959				if res == graphql.Null {
 8960					atomic.AddUint32(&invalids, 1)
 8961				}
 8962				return res
 8963			})
 8964		case "edited":
 8965			out.Values[i] = ec._AddCommentTimelineItem_edited(ctx, field, obj)
 8966			if out.Values[i] == graphql.Null {
 8967				atomic.AddUint32(&invalids, 1)
 8968			}
 8969		case "history":
 8970			out.Values[i] = ec._AddCommentTimelineItem_history(ctx, field, obj)
 8971			if out.Values[i] == graphql.Null {
 8972				atomic.AddUint32(&invalids, 1)
 8973			}
 8974		default:
 8975			panic("unknown field " + strconv.Quote(field.Name))
 8976		}
 8977	}
 8978	out.Dispatch()
 8979	if invalids > 0 {
 8980		return graphql.Null
 8981	}
 8982	return out
 8983}
 8984
 8985var bugImplementors = []string{"Bug", "Authored"}
 8986
 8987func (ec *executionContext) _Bug(ctx context.Context, sel ast.SelectionSet, obj *bug.Snapshot) graphql.Marshaler {
 8988	fields := graphql.CollectFields(ec.RequestContext, sel, bugImplementors)
 8989
 8990	out := graphql.NewFieldSet(fields)
 8991	var invalids uint32
 8992	for i, field := range fields {
 8993		switch field.Name {
 8994		case "__typename":
 8995			out.Values[i] = graphql.MarshalString("Bug")
 8996		case "id":
 8997			out.Values[i] = ec._Bug_id(ctx, field, obj)
 8998			if out.Values[i] == graphql.Null {
 8999				atomic.AddUint32(&invalids, 1)
 9000			}
 9001		case "humanId":
 9002			out.Values[i] = ec._Bug_humanId(ctx, field, obj)
 9003			if out.Values[i] == graphql.Null {
 9004				atomic.AddUint32(&invalids, 1)
 9005			}
 9006		case "status":
 9007			field := field
 9008			out.Concurrently(i, func() (res graphql.Marshaler) {
 9009				defer func() {
 9010					if r := recover(); r != nil {
 9011						ec.Error(ctx, ec.Recover(ctx, r))
 9012					}
 9013				}()
 9014				res = ec._Bug_status(ctx, field, obj)
 9015				if res == graphql.Null {
 9016					atomic.AddUint32(&invalids, 1)
 9017				}
 9018				return res
 9019			})
 9020		case "title":
 9021			out.Values[i] = ec._Bug_title(ctx, field, obj)
 9022			if out.Values[i] == graphql.Null {
 9023				atomic.AddUint32(&invalids, 1)
 9024			}
 9025		case "labels":
 9026			out.Values[i] = ec._Bug_labels(ctx, field, obj)
 9027			if out.Values[i] == graphql.Null {
 9028				atomic.AddUint32(&invalids, 1)
 9029			}
 9030		case "author":
 9031			out.Values[i] = ec._Bug_author(ctx, field, obj)
 9032			if out.Values[i] == graphql.Null {
 9033				atomic.AddUint32(&invalids, 1)
 9034			}
 9035		case "createdAt":
 9036			out.Values[i] = ec._Bug_createdAt(ctx, field, obj)
 9037			if out.Values[i] == graphql.Null {
 9038				atomic.AddUint32(&invalids, 1)
 9039			}
 9040		case "lastEdit":
 9041			field := field
 9042			out.Concurrently(i, func() (res graphql.Marshaler) {
 9043				defer func() {
 9044					if r := recover(); r != nil {
 9045						ec.Error(ctx, ec.Recover(ctx, r))
 9046					}
 9047				}()
 9048				res = ec._Bug_lastEdit(ctx, field, obj)
 9049				if res == graphql.Null {
 9050					atomic.AddUint32(&invalids, 1)
 9051				}
 9052				return res
 9053			})
 9054		case "actors":
 9055			field := field
 9056			out.Concurrently(i, func() (res graphql.Marshaler) {
 9057				defer func() {
 9058					if r := recover(); r != nil {
 9059						ec.Error(ctx, ec.Recover(ctx, r))
 9060					}
 9061				}()
 9062				res = ec._Bug_actors(ctx, field, obj)
 9063				if res == graphql.Null {
 9064					atomic.AddUint32(&invalids, 1)
 9065				}
 9066				return res
 9067			})
 9068		case "participants":
 9069			field := field
 9070			out.Concurrently(i, func() (res graphql.Marshaler) {
 9071				defer func() {
 9072					if r := recover(); r != nil {
 9073						ec.Error(ctx, ec.Recover(ctx, r))
 9074					}
 9075				}()
 9076				res = ec._Bug_participants(ctx, field, obj)
 9077				if res == graphql.Null {
 9078					atomic.AddUint32(&invalids, 1)
 9079				}
 9080				return res
 9081			})
 9082		case "comments":
 9083			field := field
 9084			out.Concurrently(i, func() (res graphql.Marshaler) {
 9085				defer func() {
 9086					if r := recover(); r != nil {
 9087						ec.Error(ctx, ec.Recover(ctx, r))
 9088					}
 9089				}()
 9090				res = ec._Bug_comments(ctx, field, obj)
 9091				if res == graphql.Null {
 9092					atomic.AddUint32(&invalids, 1)
 9093				}
 9094				return res
 9095			})
 9096		case "timeline":
 9097			field := field
 9098			out.Concurrently(i, func() (res graphql.Marshaler) {
 9099				defer func() {
 9100					if r := recover(); r != nil {
 9101						ec.Error(ctx, ec.Recover(ctx, r))
 9102					}
 9103				}()
 9104				res = ec._Bug_timeline(ctx, field, obj)
 9105				if res == graphql.Null {
 9106					atomic.AddUint32(&invalids, 1)
 9107				}
 9108				return res
 9109			})
 9110		case "operations":
 9111			field := field
 9112			out.Concurrently(i, func() (res graphql.Marshaler) {
 9113				defer func() {
 9114					if r := recover(); r != nil {
 9115						ec.Error(ctx, ec.Recover(ctx, r))
 9116					}
 9117				}()
 9118				res = ec._Bug_operations(ctx, field, obj)
 9119				if res == graphql.Null {
 9120					atomic.AddUint32(&invalids, 1)
 9121				}
 9122				return res
 9123			})
 9124		default:
 9125			panic("unknown field " + strconv.Quote(field.Name))
 9126		}
 9127	}
 9128	out.Dispatch()
 9129	if invalids > 0 {
 9130		return graphql.Null
 9131	}
 9132	return out
 9133}
 9134
 9135var bugConnectionImplementors = []string{"BugConnection"}
 9136
 9137func (ec *executionContext) _BugConnection(ctx context.Context, sel ast.SelectionSet, obj *models.BugConnection) graphql.Marshaler {
 9138	fields := graphql.CollectFields(ec.RequestContext, sel, bugConnectionImplementors)
 9139
 9140	out := graphql.NewFieldSet(fields)
 9141	var invalids uint32
 9142	for i, field := range fields {
 9143		switch field.Name {
 9144		case "__typename":
 9145			out.Values[i] = graphql.MarshalString("BugConnection")
 9146		case "edges":
 9147			out.Values[i] = ec._BugConnection_edges(ctx, field, obj)
 9148			if out.Values[i] == graphql.Null {
 9149				invalids++
 9150			}
 9151		case "nodes":
 9152			out.Values[i] = ec._BugConnection_nodes(ctx, field, obj)
 9153			if out.Values[i] == graphql.Null {
 9154				invalids++
 9155			}
 9156		case "pageInfo":
 9157			out.Values[i] = ec._BugConnection_pageInfo(ctx, field, obj)
 9158			if out.Values[i] == graphql.Null {
 9159				invalids++
 9160			}
 9161		case "totalCount":
 9162			out.Values[i] = ec._BugConnection_totalCount(ctx, field, obj)
 9163			if out.Values[i] == graphql.Null {
 9164				invalids++
 9165			}
 9166		default:
 9167			panic("unknown field " + strconv.Quote(field.Name))
 9168		}
 9169	}
 9170	out.Dispatch()
 9171	if invalids > 0 {
 9172		return graphql.Null
 9173	}
 9174	return out
 9175}
 9176
 9177var bugEdgeImplementors = []string{"BugEdge"}
 9178
 9179func (ec *executionContext) _BugEdge(ctx context.Context, sel ast.SelectionSet, obj *models.BugEdge) graphql.Marshaler {
 9180	fields := graphql.CollectFields(ec.RequestContext, sel, bugEdgeImplementors)
 9181
 9182	out := graphql.NewFieldSet(fields)
 9183	var invalids uint32
 9184	for i, field := range fields {
 9185		switch field.Name {
 9186		case "__typename":
 9187			out.Values[i] = graphql.MarshalString("BugEdge")
 9188		case "cursor":
 9189			out.Values[i] = ec._BugEdge_cursor(ctx, field, obj)
 9190			if out.Values[i] == graphql.Null {
 9191				invalids++
 9192			}
 9193		case "node":
 9194			out.Values[i] = ec._BugEdge_node(ctx, field, obj)
 9195			if out.Values[i] == graphql.Null {
 9196				invalids++
 9197			}
 9198		default:
 9199			panic("unknown field " + strconv.Quote(field.Name))
 9200		}
 9201	}
 9202	out.Dispatch()
 9203	if invalids > 0 {
 9204		return graphql.Null
 9205	}
 9206	return out
 9207}
 9208
 9209var changeLabelPayloadImplementors = []string{"ChangeLabelPayload"}
 9210
 9211func (ec *executionContext) _ChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, obj *models.ChangeLabelPayload) graphql.Marshaler {
 9212	fields := graphql.CollectFields(ec.RequestContext, sel, changeLabelPayloadImplementors)
 9213
 9214	out := graphql.NewFieldSet(fields)
 9215	var invalids uint32
 9216	for i, field := range fields {
 9217		switch field.Name {
 9218		case "__typename":
 9219			out.Values[i] = graphql.MarshalString("ChangeLabelPayload")
 9220		case "clientMutationId":
 9221			out.Values[i] = ec._ChangeLabelPayload_clientMutationId(ctx, field, obj)
 9222		case "bug":
 9223			out.Values[i] = ec._ChangeLabelPayload_bug(ctx, field, obj)
 9224			if out.Values[i] == graphql.Null {
 9225				invalids++
 9226			}
 9227		case "operation":
 9228			out.Values[i] = ec._ChangeLabelPayload_operation(ctx, field, obj)
 9229			if out.Values[i] == graphql.Null {
 9230				invalids++
 9231			}
 9232		case "results":
 9233			out.Values[i] = ec._ChangeLabelPayload_results(ctx, field, obj)
 9234			if out.Values[i] == graphql.Null {
 9235				invalids++
 9236			}
 9237		default:
 9238			panic("unknown field " + strconv.Quote(field.Name))
 9239		}
 9240	}
 9241	out.Dispatch()
 9242	if invalids > 0 {
 9243		return graphql.Null
 9244	}
 9245	return out
 9246}
 9247
 9248var closeBugPayloadImplementors = []string{"CloseBugPayload"}
 9249
 9250func (ec *executionContext) _CloseBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.CloseBugPayload) graphql.Marshaler {
 9251	fields := graphql.CollectFields(ec.RequestContext, sel, closeBugPayloadImplementors)
 9252
 9253	out := graphql.NewFieldSet(fields)
 9254	var invalids uint32
 9255	for i, field := range fields {
 9256		switch field.Name {
 9257		case "__typename":
 9258			out.Values[i] = graphql.MarshalString("CloseBugPayload")
 9259		case "clientMutationId":
 9260			out.Values[i] = ec._CloseBugPayload_clientMutationId(ctx, field, obj)
 9261		case "bug":
 9262			out.Values[i] = ec._CloseBugPayload_bug(ctx, field, obj)
 9263			if out.Values[i] == graphql.Null {
 9264				invalids++
 9265			}
 9266		case "operation":
 9267			out.Values[i] = ec._CloseBugPayload_operation(ctx, field, obj)
 9268			if out.Values[i] == graphql.Null {
 9269				invalids++
 9270			}
 9271		default:
 9272			panic("unknown field " + strconv.Quote(field.Name))
 9273		}
 9274	}
 9275	out.Dispatch()
 9276	if invalids > 0 {
 9277		return graphql.Null
 9278	}
 9279	return out
 9280}
 9281
 9282var colorImplementors = []string{"Color"}
 9283
 9284func (ec *executionContext) _Color(ctx context.Context, sel ast.SelectionSet, obj *color.RGBA) graphql.Marshaler {
 9285	fields := graphql.CollectFields(ec.RequestContext, sel, colorImplementors)
 9286
 9287	out := graphql.NewFieldSet(fields)
 9288	var invalids uint32
 9289	for i, field := range fields {
 9290		switch field.Name {
 9291		case "__typename":
 9292			out.Values[i] = graphql.MarshalString("Color")
 9293		case "R":
 9294			field := field
 9295			out.Concurrently(i, func() (res graphql.Marshaler) {
 9296				defer func() {
 9297					if r := recover(); r != nil {
 9298						ec.Error(ctx, ec.Recover(ctx, r))
 9299					}
 9300				}()
 9301				res = ec._Color_R(ctx, field, obj)
 9302				if res == graphql.Null {
 9303					atomic.AddUint32(&invalids, 1)
 9304				}
 9305				return res
 9306			})
 9307		case "G":
 9308			field := field
 9309			out.Concurrently(i, func() (res graphql.Marshaler) {
 9310				defer func() {
 9311					if r := recover(); r != nil {
 9312						ec.Error(ctx, ec.Recover(ctx, r))
 9313					}
 9314				}()
 9315				res = ec._Color_G(ctx, field, obj)
 9316				if res == graphql.Null {
 9317					atomic.AddUint32(&invalids, 1)
 9318				}
 9319				return res
 9320			})
 9321		case "B":
 9322			field := field
 9323			out.Concurrently(i, func() (res graphql.Marshaler) {
 9324				defer func() {
 9325					if r := recover(); r != nil {
 9326						ec.Error(ctx, ec.Recover(ctx, r))
 9327					}
 9328				}()
 9329				res = ec._Color_B(ctx, field, obj)
 9330				if res == graphql.Null {
 9331					atomic.AddUint32(&invalids, 1)
 9332				}
 9333				return res
 9334			})
 9335		default:
 9336			panic("unknown field " + strconv.Quote(field.Name))
 9337		}
 9338	}
 9339	out.Dispatch()
 9340	if invalids > 0 {
 9341		return graphql.Null
 9342	}
 9343	return out
 9344}
 9345
 9346var commentImplementors = []string{"Comment", "Authored"}
 9347
 9348func (ec *executionContext) _Comment(ctx context.Context, sel ast.SelectionSet, obj *bug.Comment) graphql.Marshaler {
 9349	fields := graphql.CollectFields(ec.RequestContext, sel, commentImplementors)
 9350
 9351	out := graphql.NewFieldSet(fields)
 9352	var invalids uint32
 9353	for i, field := range fields {
 9354		switch field.Name {
 9355		case "__typename":
 9356			out.Values[i] = graphql.MarshalString("Comment")
 9357		case "author":
 9358			out.Values[i] = ec._Comment_author(ctx, field, obj)
 9359			if out.Values[i] == graphql.Null {
 9360				invalids++
 9361			}
 9362		case "message":
 9363			out.Values[i] = ec._Comment_message(ctx, field, obj)
 9364			if out.Values[i] == graphql.Null {
 9365				invalids++
 9366			}
 9367		case "files":
 9368			out.Values[i] = ec._Comment_files(ctx, field, obj)
 9369			if out.Values[i] == graphql.Null {
 9370				invalids++
 9371			}
 9372		default:
 9373			panic("unknown field " + strconv.Quote(field.Name))
 9374		}
 9375	}
 9376	out.Dispatch()
 9377	if invalids > 0 {
 9378		return graphql.Null
 9379	}
 9380	return out
 9381}
 9382
 9383var commentConnectionImplementors = []string{"CommentConnection"}
 9384
 9385func (ec *executionContext) _CommentConnection(ctx context.Context, sel ast.SelectionSet, obj *models.CommentConnection) graphql.Marshaler {
 9386	fields := graphql.CollectFields(ec.RequestContext, sel, commentConnectionImplementors)
 9387
 9388	out := graphql.NewFieldSet(fields)
 9389	var invalids uint32
 9390	for i, field := range fields {
 9391		switch field.Name {
 9392		case "__typename":
 9393			out.Values[i] = graphql.MarshalString("CommentConnection")
 9394		case "edges":
 9395			out.Values[i] = ec._CommentConnection_edges(ctx, field, obj)
 9396			if out.Values[i] == graphql.Null {
 9397				invalids++
 9398			}
 9399		case "nodes":
 9400			out.Values[i] = ec._CommentConnection_nodes(ctx, field, obj)
 9401			if out.Values[i] == graphql.Null {
 9402				invalids++
 9403			}
 9404		case "pageInfo":
 9405			out.Values[i] = ec._CommentConnection_pageInfo(ctx, field, obj)
 9406			if out.Values[i] == graphql.Null {
 9407				invalids++
 9408			}
 9409		case "totalCount":
 9410			out.Values[i] = ec._CommentConnection_totalCount(ctx, field, obj)
 9411			if out.Values[i] == graphql.Null {
 9412				invalids++
 9413			}
 9414		default:
 9415			panic("unknown field " + strconv.Quote(field.Name))
 9416		}
 9417	}
 9418	out.Dispatch()
 9419	if invalids > 0 {
 9420		return graphql.Null
 9421	}
 9422	return out
 9423}
 9424
 9425var commentEdgeImplementors = []string{"CommentEdge"}
 9426
 9427func (ec *executionContext) _CommentEdge(ctx context.Context, sel ast.SelectionSet, obj *models.CommentEdge) graphql.Marshaler {
 9428	fields := graphql.CollectFields(ec.RequestContext, sel, commentEdgeImplementors)
 9429
 9430	out := graphql.NewFieldSet(fields)
 9431	var invalids uint32
 9432	for i, field := range fields {
 9433		switch field.Name {
 9434		case "__typename":
 9435			out.Values[i] = graphql.MarshalString("CommentEdge")
 9436		case "cursor":
 9437			out.Values[i] = ec._CommentEdge_cursor(ctx, field, obj)
 9438			if out.Values[i] == graphql.Null {
 9439				invalids++
 9440			}
 9441		case "node":
 9442			out.Values[i] = ec._CommentEdge_node(ctx, field, obj)
 9443			if out.Values[i] == graphql.Null {
 9444				invalids++
 9445			}
 9446		default:
 9447			panic("unknown field " + strconv.Quote(field.Name))
 9448		}
 9449	}
 9450	out.Dispatch()
 9451	if invalids > 0 {
 9452		return graphql.Null
 9453	}
 9454	return out
 9455}
 9456
 9457var commentHistoryStepImplementors = []string{"CommentHistoryStep"}
 9458
 9459func (ec *executionContext) _CommentHistoryStep(ctx context.Context, sel ast.SelectionSet, obj *bug.CommentHistoryStep) graphql.Marshaler {
 9460	fields := graphql.CollectFields(ec.RequestContext, sel, commentHistoryStepImplementors)
 9461
 9462	out := graphql.NewFieldSet(fields)
 9463	var invalids uint32
 9464	for i, field := range fields {
 9465		switch field.Name {
 9466		case "__typename":
 9467			out.Values[i] = graphql.MarshalString("CommentHistoryStep")
 9468		case "message":
 9469			out.Values[i] = ec._CommentHistoryStep_message(ctx, field, obj)
 9470			if out.Values[i] == graphql.Null {
 9471				atomic.AddUint32(&invalids, 1)
 9472			}
 9473		case "date":
 9474			field := field
 9475			out.Concurrently(i, func() (res graphql.Marshaler) {
 9476				defer func() {
 9477					if r := recover(); r != nil {
 9478						ec.Error(ctx, ec.Recover(ctx, r))
 9479					}
 9480				}()
 9481				res = ec._CommentHistoryStep_date(ctx, field, obj)
 9482				if res == graphql.Null {
 9483					atomic.AddUint32(&invalids, 1)
 9484				}
 9485				return res
 9486			})
 9487		default:
 9488			panic("unknown field " + strconv.Quote(field.Name))
 9489		}
 9490	}
 9491	out.Dispatch()
 9492	if invalids > 0 {
 9493		return graphql.Null
 9494	}
 9495	return out
 9496}
 9497
 9498var commitAsNeededPayloadImplementors = []string{"CommitAsNeededPayload"}
 9499
 9500func (ec *executionContext) _CommitAsNeededPayload(ctx context.Context, sel ast.SelectionSet, obj *models.CommitAsNeededPayload) graphql.Marshaler {
 9501	fields := graphql.CollectFields(ec.RequestContext, sel, commitAsNeededPayloadImplementors)
 9502
 9503	out := graphql.NewFieldSet(fields)
 9504	var invalids uint32
 9505	for i, field := range fields {
 9506		switch field.Name {
 9507		case "__typename":
 9508			out.Values[i] = graphql.MarshalString("CommitAsNeededPayload")
 9509		case "clientMutationId":
 9510			out.Values[i] = ec._CommitAsNeededPayload_clientMutationId(ctx, field, obj)
 9511		case "bug":
 9512			out.Values[i] = ec._CommitAsNeededPayload_bug(ctx, field, obj)
 9513			if out.Values[i] == graphql.Null {
 9514				invalids++
 9515			}
 9516		default:
 9517			panic("unknown field " + strconv.Quote(field.Name))
 9518		}
 9519	}
 9520	out.Dispatch()
 9521	if invalids > 0 {
 9522		return graphql.Null
 9523	}
 9524	return out
 9525}
 9526
 9527var commitPayloadImplementors = []string{"CommitPayload"}
 9528
 9529func (ec *executionContext) _CommitPayload(ctx context.Context, sel ast.SelectionSet, obj *models.CommitPayload) graphql.Marshaler {
 9530	fields := graphql.CollectFields(ec.RequestContext, sel, commitPayloadImplementors)
 9531
 9532	out := graphql.NewFieldSet(fields)
 9533	var invalids uint32
 9534	for i, field := range fields {
 9535		switch field.Name {
 9536		case "__typename":
 9537			out.Values[i] = graphql.MarshalString("CommitPayload")
 9538		case "clientMutationId":
 9539			out.Values[i] = ec._CommitPayload_clientMutationId(ctx, field, obj)
 9540		case "bug":
 9541			out.Values[i] = ec._CommitPayload_bug(ctx, field, obj)
 9542			if out.Values[i] == graphql.Null {
 9543				invalids++
 9544			}
 9545		default:
 9546			panic("unknown field " + strconv.Quote(field.Name))
 9547		}
 9548	}
 9549	out.Dispatch()
 9550	if invalids > 0 {
 9551		return graphql.Null
 9552	}
 9553	return out
 9554}
 9555
 9556var createOperationImplementors = []string{"CreateOperation", "Operation", "Authored"}
 9557
 9558func (ec *executionContext) _CreateOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.CreateOperation) graphql.Marshaler {
 9559	fields := graphql.CollectFields(ec.RequestContext, sel, createOperationImplementors)
 9560
 9561	out := graphql.NewFieldSet(fields)
 9562	var invalids uint32
 9563	for i, field := range fields {
 9564		switch field.Name {
 9565		case "__typename":
 9566			out.Values[i] = graphql.MarshalString("CreateOperation")
 9567		case "hash":
 9568			out.Values[i] = ec._CreateOperation_hash(ctx, field, obj)
 9569			if out.Values[i] == graphql.Null {
 9570				atomic.AddUint32(&invalids, 1)
 9571			}
 9572		case "author":
 9573			out.Values[i] = ec._CreateOperation_author(ctx, field, obj)
 9574			if out.Values[i] == graphql.Null {
 9575				atomic.AddUint32(&invalids, 1)
 9576			}
 9577		case "date":
 9578			field := field
 9579			out.Concurrently(i, func() (res graphql.Marshaler) {
 9580				defer func() {
 9581					if r := recover(); r != nil {
 9582						ec.Error(ctx, ec.Recover(ctx, r))
 9583					}
 9584				}()
 9585				res = ec._CreateOperation_date(ctx, field, obj)
 9586				if res == graphql.Null {
 9587					atomic.AddUint32(&invalids, 1)
 9588				}
 9589				return res
 9590			})
 9591		case "title":
 9592			out.Values[i] = ec._CreateOperation_title(ctx, field, obj)
 9593			if out.Values[i] == graphql.Null {
 9594				atomic.AddUint32(&invalids, 1)
 9595			}
 9596		case "message":
 9597			out.Values[i] = ec._CreateOperation_message(ctx, field, obj)
 9598			if out.Values[i] == graphql.Null {
 9599				atomic.AddUint32(&invalids, 1)
 9600			}
 9601		case "files":
 9602			out.Values[i] = ec._CreateOperation_files(ctx, field, obj)
 9603			if out.Values[i] == graphql.Null {
 9604				atomic.AddUint32(&invalids, 1)
 9605			}
 9606		default:
 9607			panic("unknown field " + strconv.Quote(field.Name))
 9608		}
 9609	}
 9610	out.Dispatch()
 9611	if invalids > 0 {
 9612		return graphql.Null
 9613	}
 9614	return out
 9615}
 9616
 9617var createTimelineItemImplementors = []string{"CreateTimelineItem", "TimelineItem", "Authored"}
 9618
 9619func (ec *executionContext) _CreateTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.CreateTimelineItem) graphql.Marshaler {
 9620	fields := graphql.CollectFields(ec.RequestContext, sel, createTimelineItemImplementors)
 9621
 9622	out := graphql.NewFieldSet(fields)
 9623	var invalids uint32
 9624	for i, field := range fields {
 9625		switch field.Name {
 9626		case "__typename":
 9627			out.Values[i] = graphql.MarshalString("CreateTimelineItem")
 9628		case "hash":
 9629			out.Values[i] = ec._CreateTimelineItem_hash(ctx, field, obj)
 9630			if out.Values[i] == graphql.Null {
 9631				atomic.AddUint32(&invalids, 1)
 9632			}
 9633		case "author":
 9634			out.Values[i] = ec._CreateTimelineItem_author(ctx, field, obj)
 9635			if out.Values[i] == graphql.Null {
 9636				atomic.AddUint32(&invalids, 1)
 9637			}
 9638		case "message":
 9639			out.Values[i] = ec._CreateTimelineItem_message(ctx, field, obj)
 9640			if out.Values[i] == graphql.Null {
 9641				atomic.AddUint32(&invalids, 1)
 9642			}
 9643		case "messageIsEmpty":
 9644			out.Values[i] = ec._CreateTimelineItem_messageIsEmpty(ctx, field, obj)
 9645			if out.Values[i] == graphql.Null {
 9646				atomic.AddUint32(&invalids, 1)
 9647			}
 9648		case "files":
 9649			out.Values[i] = ec._CreateTimelineItem_files(ctx, field, obj)
 9650			if out.Values[i] == graphql.Null {
 9651				atomic.AddUint32(&invalids, 1)
 9652			}
 9653		case "createdAt":
 9654			field := field
 9655			out.Concurrently(i, func() (res graphql.Marshaler) {
 9656				defer func() {
 9657					if r := recover(); r != nil {
 9658						ec.Error(ctx, ec.Recover(ctx, r))
 9659					}
 9660				}()
 9661				res = ec._CreateTimelineItem_createdAt(ctx, field, obj)
 9662				if res == graphql.Null {
 9663					atomic.AddUint32(&invalids, 1)
 9664				}
 9665				return res
 9666			})
 9667		case "lastEdit":
 9668			field := field
 9669			out.Concurrently(i, func() (res graphql.Marshaler) {
 9670				defer func() {
 9671					if r := recover(); r != nil {
 9672						ec.Error(ctx, ec.Recover(ctx, r))
 9673					}
 9674				}()
 9675				res = ec._CreateTimelineItem_lastEdit(ctx, field, obj)
 9676				if res == graphql.Null {
 9677					atomic.AddUint32(&invalids, 1)
 9678				}
 9679				return res
 9680			})
 9681		case "edited":
 9682			out.Values[i] = ec._CreateTimelineItem_edited(ctx, field, obj)
 9683			if out.Values[i] == graphql.Null {
 9684				atomic.AddUint32(&invalids, 1)
 9685			}
 9686		case "history":
 9687			out.Values[i] = ec._CreateTimelineItem_history(ctx, field, obj)
 9688			if out.Values[i] == graphql.Null {
 9689				atomic.AddUint32(&invalids, 1)
 9690			}
 9691		default:
 9692			panic("unknown field " + strconv.Quote(field.Name))
 9693		}
 9694	}
 9695	out.Dispatch()
 9696	if invalids > 0 {
 9697		return graphql.Null
 9698	}
 9699	return out
 9700}
 9701
 9702var editCommentOperationImplementors = []string{"EditCommentOperation", "Operation", "Authored"}
 9703
 9704func (ec *executionContext) _EditCommentOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.EditCommentOperation) graphql.Marshaler {
 9705	fields := graphql.CollectFields(ec.RequestContext, sel, editCommentOperationImplementors)
 9706
 9707	out := graphql.NewFieldSet(fields)
 9708	var invalids uint32
 9709	for i, field := range fields {
 9710		switch field.Name {
 9711		case "__typename":
 9712			out.Values[i] = graphql.MarshalString("EditCommentOperation")
 9713		case "hash":
 9714			out.Values[i] = ec._EditCommentOperation_hash(ctx, field, obj)
 9715			if out.Values[i] == graphql.Null {
 9716				atomic.AddUint32(&invalids, 1)
 9717			}
 9718		case "author":
 9719			out.Values[i] = ec._EditCommentOperation_author(ctx, field, obj)
 9720			if out.Values[i] == graphql.Null {
 9721				atomic.AddUint32(&invalids, 1)
 9722			}
 9723		case "date":
 9724			field := field
 9725			out.Concurrently(i, func() (res graphql.Marshaler) {
 9726				defer func() {
 9727					if r := recover(); r != nil {
 9728						ec.Error(ctx, ec.Recover(ctx, r))
 9729					}
 9730				}()
 9731				res = ec._EditCommentOperation_date(ctx, field, obj)
 9732				if res == graphql.Null {
 9733					atomic.AddUint32(&invalids, 1)
 9734				}
 9735				return res
 9736			})
 9737		case "target":
 9738			out.Values[i] = ec._EditCommentOperation_target(ctx, field, obj)
 9739			if out.Values[i] == graphql.Null {
 9740				atomic.AddUint32(&invalids, 1)
 9741			}
 9742		case "message":
 9743			out.Values[i] = ec._EditCommentOperation_message(ctx, field, obj)
 9744			if out.Values[i] == graphql.Null {
 9745				atomic.AddUint32(&invalids, 1)
 9746			}
 9747		case "files":
 9748			out.Values[i] = ec._EditCommentOperation_files(ctx, field, obj)
 9749			if out.Values[i] == graphql.Null {
 9750				atomic.AddUint32(&invalids, 1)
 9751			}
 9752		default:
 9753			panic("unknown field " + strconv.Quote(field.Name))
 9754		}
 9755	}
 9756	out.Dispatch()
 9757	if invalids > 0 {
 9758		return graphql.Null
 9759	}
 9760	return out
 9761}
 9762
 9763var identityImplementors = []string{"Identity"}
 9764
 9765func (ec *executionContext) _Identity(ctx context.Context, sel ast.SelectionSet, obj *identity.Interface) graphql.Marshaler {
 9766	fields := graphql.CollectFields(ec.RequestContext, sel, identityImplementors)
 9767
 9768	out := graphql.NewFieldSet(fields)
 9769	var invalids uint32
 9770	for i, field := range fields {
 9771		switch field.Name {
 9772		case "__typename":
 9773			out.Values[i] = graphql.MarshalString("Identity")
 9774		case "id":
 9775			field := field
 9776			out.Concurrently(i, func() (res graphql.Marshaler) {
 9777				defer func() {
 9778					if r := recover(); r != nil {
 9779						ec.Error(ctx, ec.Recover(ctx, r))
 9780					}
 9781				}()
 9782				res = ec._Identity_id(ctx, field, obj)
 9783				if res == graphql.Null {
 9784					atomic.AddUint32(&invalids, 1)
 9785				}
 9786				return res
 9787			})
 9788		case "humanId":
 9789			field := field
 9790			out.Concurrently(i, func() (res graphql.Marshaler) {
 9791				defer func() {
 9792					if r := recover(); r != nil {
 9793						ec.Error(ctx, ec.Recover(ctx, r))
 9794					}
 9795				}()
 9796				res = ec._Identity_humanId(ctx, field, obj)
 9797				if res == graphql.Null {
 9798					atomic.AddUint32(&invalids, 1)
 9799				}
 9800				return res
 9801			})
 9802		case "name":
 9803			field := field
 9804			out.Concurrently(i, func() (res graphql.Marshaler) {
 9805				defer func() {
 9806					if r := recover(); r != nil {
 9807						ec.Error(ctx, ec.Recover(ctx, r))
 9808					}
 9809				}()
 9810				res = ec._Identity_name(ctx, field, obj)
 9811				return res
 9812			})
 9813		case "email":
 9814			field := field
 9815			out.Concurrently(i, func() (res graphql.Marshaler) {
 9816				defer func() {
 9817					if r := recover(); r != nil {
 9818						ec.Error(ctx, ec.Recover(ctx, r))
 9819					}
 9820				}()
 9821				res = ec._Identity_email(ctx, field, obj)
 9822				return res
 9823			})
 9824		case "login":
 9825			field := field
 9826			out.Concurrently(i, func() (res graphql.Marshaler) {
 9827				defer func() {
 9828					if r := recover(); r != nil {
 9829						ec.Error(ctx, ec.Recover(ctx, r))
 9830					}
 9831				}()
 9832				res = ec._Identity_login(ctx, field, obj)
 9833				return res
 9834			})
 9835		case "displayName":
 9836			field := field
 9837			out.Concurrently(i, func() (res graphql.Marshaler) {
 9838				defer func() {
 9839					if r := recover(); r != nil {
 9840						ec.Error(ctx, ec.Recover(ctx, r))
 9841					}
 9842				}()
 9843				res = ec._Identity_displayName(ctx, field, obj)
 9844				if res == graphql.Null {
 9845					atomic.AddUint32(&invalids, 1)
 9846				}
 9847				return res
 9848			})
 9849		case "avatarUrl":
 9850			field := field
 9851			out.Concurrently(i, func() (res graphql.Marshaler) {
 9852				defer func() {
 9853					if r := recover(); r != nil {
 9854						ec.Error(ctx, ec.Recover(ctx, r))
 9855					}
 9856				}()
 9857				res = ec._Identity_avatarUrl(ctx, field, obj)
 9858				return res
 9859			})
 9860		case "isProtected":
 9861			field := field
 9862			out.Concurrently(i, func() (res graphql.Marshaler) {
 9863				defer func() {
 9864					if r := recover(); r != nil {
 9865						ec.Error(ctx, ec.Recover(ctx, r))
 9866					}
 9867				}()
 9868				res = ec._Identity_isProtected(ctx, field, obj)
 9869				if res == graphql.Null {
 9870					atomic.AddUint32(&invalids, 1)
 9871				}
 9872				return res
 9873			})
 9874		default:
 9875			panic("unknown field " + strconv.Quote(field.Name))
 9876		}
 9877	}
 9878	out.Dispatch()
 9879	if invalids > 0 {
 9880		return graphql.Null
 9881	}
 9882	return out
 9883}
 9884
 9885var identityConnectionImplementors = []string{"IdentityConnection"}
 9886
 9887func (ec *executionContext) _IdentityConnection(ctx context.Context, sel ast.SelectionSet, obj *models.IdentityConnection) graphql.Marshaler {
 9888	fields := graphql.CollectFields(ec.RequestContext, sel, identityConnectionImplementors)
 9889
 9890	out := graphql.NewFieldSet(fields)
 9891	var invalids uint32
 9892	for i, field := range fields {
 9893		switch field.Name {
 9894		case "__typename":
 9895			out.Values[i] = graphql.MarshalString("IdentityConnection")
 9896		case "edges":
 9897			out.Values[i] = ec._IdentityConnection_edges(ctx, field, obj)
 9898			if out.Values[i] == graphql.Null {
 9899				invalids++
 9900			}
 9901		case "nodes":
 9902			out.Values[i] = ec._IdentityConnection_nodes(ctx, field, obj)
 9903			if out.Values[i] == graphql.Null {
 9904				invalids++
 9905			}
 9906		case "pageInfo":
 9907			out.Values[i] = ec._IdentityConnection_pageInfo(ctx, field, obj)
 9908			if out.Values[i] == graphql.Null {
 9909				invalids++
 9910			}
 9911		case "totalCount":
 9912			out.Values[i] = ec._IdentityConnection_totalCount(ctx, field, obj)
 9913			if out.Values[i] == graphql.Null {
 9914				invalids++
 9915			}
 9916		default:
 9917			panic("unknown field " + strconv.Quote(field.Name))
 9918		}
 9919	}
 9920	out.Dispatch()
 9921	if invalids > 0 {
 9922		return graphql.Null
 9923	}
 9924	return out
 9925}
 9926
 9927var identityEdgeImplementors = []string{"IdentityEdge"}
 9928
 9929func (ec *executionContext) _IdentityEdge(ctx context.Context, sel ast.SelectionSet, obj *models.IdentityEdge) graphql.Marshaler {
 9930	fields := graphql.CollectFields(ec.RequestContext, sel, identityEdgeImplementors)
 9931
 9932	out := graphql.NewFieldSet(fields)
 9933	var invalids uint32
 9934	for i, field := range fields {
 9935		switch field.Name {
 9936		case "__typename":
 9937			out.Values[i] = graphql.MarshalString("IdentityEdge")
 9938		case "cursor":
 9939			out.Values[i] = ec._IdentityEdge_cursor(ctx, field, obj)
 9940			if out.Values[i] == graphql.Null {
 9941				invalids++
 9942			}
 9943		case "node":
 9944			out.Values[i] = ec._IdentityEdge_node(ctx, field, obj)
 9945			if out.Values[i] == graphql.Null {
 9946				invalids++
 9947			}
 9948		default:
 9949			panic("unknown field " + strconv.Quote(field.Name))
 9950		}
 9951	}
 9952	out.Dispatch()
 9953	if invalids > 0 {
 9954		return graphql.Null
 9955	}
 9956	return out
 9957}
 9958
 9959var labelImplementors = []string{"Label"}
 9960
 9961func (ec *executionContext) _Label(ctx context.Context, sel ast.SelectionSet, obj *bug.Label) graphql.Marshaler {
 9962	fields := graphql.CollectFields(ec.RequestContext, sel, labelImplementors)
 9963
 9964	out := graphql.NewFieldSet(fields)
 9965	var invalids uint32
 9966	for i, field := range fields {
 9967		switch field.Name {
 9968		case "__typename":
 9969			out.Values[i] = graphql.MarshalString("Label")
 9970		case "name":
 9971			field := field
 9972			out.Concurrently(i, func() (res graphql.Marshaler) {
 9973				defer func() {
 9974					if r := recover(); r != nil {
 9975						ec.Error(ctx, ec.Recover(ctx, r))
 9976					}
 9977				}()
 9978				res = ec._Label_name(ctx, field, obj)
 9979				if res == graphql.Null {
 9980					atomic.AddUint32(&invalids, 1)
 9981				}
 9982				return res
 9983			})
 9984		case "color":
 9985			field := field
 9986			out.Concurrently(i, func() (res graphql.Marshaler) {
 9987				defer func() {
 9988					if r := recover(); r != nil {
 9989						ec.Error(ctx, ec.Recover(ctx, r))
 9990					}
 9991				}()
 9992				res = ec._Label_color(ctx, field, obj)
 9993				if res == graphql.Null {
 9994					atomic.AddUint32(&invalids, 1)
 9995				}
 9996				return res
 9997			})
 9998		default:
 9999			panic("unknown field " + strconv.Quote(field.Name))
10000		}
10001	}
10002	out.Dispatch()
10003	if invalids > 0 {
10004		return graphql.Null
10005	}
10006	return out
10007}
10008
10009var labelChangeOperationImplementors = []string{"LabelChangeOperation", "Operation", "Authored"}
10010
10011func (ec *executionContext) _LabelChangeOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeOperation) graphql.Marshaler {
10012	fields := graphql.CollectFields(ec.RequestContext, sel, labelChangeOperationImplementors)
10013
10014	out := graphql.NewFieldSet(fields)
10015	var invalids uint32
10016	for i, field := range fields {
10017		switch field.Name {
10018		case "__typename":
10019			out.Values[i] = graphql.MarshalString("LabelChangeOperation")
10020		case "hash":
10021			out.Values[i] = ec._LabelChangeOperation_hash(ctx, field, obj)
10022			if out.Values[i] == graphql.Null {
10023				atomic.AddUint32(&invalids, 1)
10024			}
10025		case "author":
10026			out.Values[i] = ec._LabelChangeOperation_author(ctx, field, obj)
10027			if out.Values[i] == graphql.Null {
10028				atomic.AddUint32(&invalids, 1)
10029			}
10030		case "date":
10031			field := field
10032			out.Concurrently(i, func() (res graphql.Marshaler) {
10033				defer func() {
10034					if r := recover(); r != nil {
10035						ec.Error(ctx, ec.Recover(ctx, r))
10036					}
10037				}()
10038				res = ec._LabelChangeOperation_date(ctx, field, obj)
10039				if res == graphql.Null {
10040					atomic.AddUint32(&invalids, 1)
10041				}
10042				return res
10043			})
10044		case "added":
10045			out.Values[i] = ec._LabelChangeOperation_added(ctx, field, obj)
10046			if out.Values[i] == graphql.Null {
10047				atomic.AddUint32(&invalids, 1)
10048			}
10049		case "removed":
10050			out.Values[i] = ec._LabelChangeOperation_removed(ctx, field, obj)
10051			if out.Values[i] == graphql.Null {
10052				atomic.AddUint32(&invalids, 1)
10053			}
10054		default:
10055			panic("unknown field " + strconv.Quote(field.Name))
10056		}
10057	}
10058	out.Dispatch()
10059	if invalids > 0 {
10060		return graphql.Null
10061	}
10062	return out
10063}
10064
10065var labelChangeResultImplementors = []string{"LabelChangeResult"}
10066
10067func (ec *executionContext) _LabelChangeResult(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeResult) graphql.Marshaler {
10068	fields := graphql.CollectFields(ec.RequestContext, sel, labelChangeResultImplementors)
10069
10070	out := graphql.NewFieldSet(fields)
10071	var invalids uint32
10072	for i, field := range fields {
10073		switch field.Name {
10074		case "__typename":
10075			out.Values[i] = graphql.MarshalString("LabelChangeResult")
10076		case "label":
10077			out.Values[i] = ec._LabelChangeResult_label(ctx, field, obj)
10078			if out.Values[i] == graphql.Null {
10079				atomic.AddUint32(&invalids, 1)
10080			}
10081		case "status":
10082			field := field
10083			out.Concurrently(i, func() (res graphql.Marshaler) {
10084				defer func() {
10085					if r := recover(); r != nil {
10086						ec.Error(ctx, ec.Recover(ctx, r))
10087					}
10088				}()
10089				res = ec._LabelChangeResult_status(ctx, field, obj)
10090				if res == graphql.Null {
10091					atomic.AddUint32(&invalids, 1)
10092				}
10093				return res
10094			})
10095		default:
10096			panic("unknown field " + strconv.Quote(field.Name))
10097		}
10098	}
10099	out.Dispatch()
10100	if invalids > 0 {
10101		return graphql.Null
10102	}
10103	return out
10104}
10105
10106var labelChangeTimelineItemImplementors = []string{"LabelChangeTimelineItem", "TimelineItem", "Authored"}
10107
10108func (ec *executionContext) _LabelChangeTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.LabelChangeTimelineItem) graphql.Marshaler {
10109	fields := graphql.CollectFields(ec.RequestContext, sel, labelChangeTimelineItemImplementors)
10110
10111	out := graphql.NewFieldSet(fields)
10112	var invalids uint32
10113	for i, field := range fields {
10114		switch field.Name {
10115		case "__typename":
10116			out.Values[i] = graphql.MarshalString("LabelChangeTimelineItem")
10117		case "hash":
10118			out.Values[i] = ec._LabelChangeTimelineItem_hash(ctx, field, obj)
10119			if out.Values[i] == graphql.Null {
10120				atomic.AddUint32(&invalids, 1)
10121			}
10122		case "author":
10123			out.Values[i] = ec._LabelChangeTimelineItem_author(ctx, field, obj)
10124			if out.Values[i] == graphql.Null {
10125				atomic.AddUint32(&invalids, 1)
10126			}
10127		case "date":
10128			field := field
10129			out.Concurrently(i, func() (res graphql.Marshaler) {
10130				defer func() {
10131					if r := recover(); r != nil {
10132						ec.Error(ctx, ec.Recover(ctx, r))
10133					}
10134				}()
10135				res = ec._LabelChangeTimelineItem_date(ctx, field, obj)
10136				if res == graphql.Null {
10137					atomic.AddUint32(&invalids, 1)
10138				}
10139				return res
10140			})
10141		case "added":
10142			out.Values[i] = ec._LabelChangeTimelineItem_added(ctx, field, obj)
10143			if out.Values[i] == graphql.Null {
10144				atomic.AddUint32(&invalids, 1)
10145			}
10146		case "removed":
10147			out.Values[i] = ec._LabelChangeTimelineItem_removed(ctx, field, obj)
10148			if out.Values[i] == graphql.Null {
10149				atomic.AddUint32(&invalids, 1)
10150			}
10151		default:
10152			panic("unknown field " + strconv.Quote(field.Name))
10153		}
10154	}
10155	out.Dispatch()
10156	if invalids > 0 {
10157		return graphql.Null
10158	}
10159	return out
10160}
10161
10162var mutationImplementors = []string{"Mutation"}
10163
10164func (ec *executionContext) _Mutation(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
10165	fields := graphql.CollectFields(ec.RequestContext, sel, mutationImplementors)
10166
10167	ctx = graphql.WithResolverContext(ctx, &graphql.ResolverContext{
10168		Object: "Mutation",
10169	})
10170
10171	out := graphql.NewFieldSet(fields)
10172	var invalids uint32
10173	for i, field := range fields {
10174		switch field.Name {
10175		case "__typename":
10176			out.Values[i] = graphql.MarshalString("Mutation")
10177		case "newBug":
10178			out.Values[i] = ec._Mutation_newBug(ctx, field)
10179			if out.Values[i] == graphql.Null {
10180				invalids++
10181			}
10182		case "addComment":
10183			out.Values[i] = ec._Mutation_addComment(ctx, field)
10184			if out.Values[i] == graphql.Null {
10185				invalids++
10186			}
10187		case "changeLabels":
10188			out.Values[i] = ec._Mutation_changeLabels(ctx, field)
10189			if out.Values[i] == graphql.Null {
10190				invalids++
10191			}
10192		case "openBug":
10193			out.Values[i] = ec._Mutation_openBug(ctx, field)
10194			if out.Values[i] == graphql.Null {
10195				invalids++
10196			}
10197		case "closeBug":
10198			out.Values[i] = ec._Mutation_closeBug(ctx, field)
10199			if out.Values[i] == graphql.Null {
10200				invalids++
10201			}
10202		case "setTitle":
10203			out.Values[i] = ec._Mutation_setTitle(ctx, field)
10204			if out.Values[i] == graphql.Null {
10205				invalids++
10206			}
10207		case "commit":
10208			out.Values[i] = ec._Mutation_commit(ctx, field)
10209			if out.Values[i] == graphql.Null {
10210				invalids++
10211			}
10212		case "commitAsNeeded":
10213			out.Values[i] = ec._Mutation_commitAsNeeded(ctx, field)
10214			if out.Values[i] == graphql.Null {
10215				invalids++
10216			}
10217		default:
10218			panic("unknown field " + strconv.Quote(field.Name))
10219		}
10220	}
10221	out.Dispatch()
10222	if invalids > 0 {
10223		return graphql.Null
10224	}
10225	return out
10226}
10227
10228var newBugPayloadImplementors = []string{"NewBugPayload"}
10229
10230func (ec *executionContext) _NewBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.NewBugPayload) graphql.Marshaler {
10231	fields := graphql.CollectFields(ec.RequestContext, sel, newBugPayloadImplementors)
10232
10233	out := graphql.NewFieldSet(fields)
10234	var invalids uint32
10235	for i, field := range fields {
10236		switch field.Name {
10237		case "__typename":
10238			out.Values[i] = graphql.MarshalString("NewBugPayload")
10239		case "clientMutationId":
10240			out.Values[i] = ec._NewBugPayload_clientMutationId(ctx, field, obj)
10241		case "bug":
10242			out.Values[i] = ec._NewBugPayload_bug(ctx, field, obj)
10243			if out.Values[i] == graphql.Null {
10244				invalids++
10245			}
10246		case "operation":
10247			out.Values[i] = ec._NewBugPayload_operation(ctx, field, obj)
10248			if out.Values[i] == graphql.Null {
10249				invalids++
10250			}
10251		default:
10252			panic("unknown field " + strconv.Quote(field.Name))
10253		}
10254	}
10255	out.Dispatch()
10256	if invalids > 0 {
10257		return graphql.Null
10258	}
10259	return out
10260}
10261
10262var openBugPayloadImplementors = []string{"OpenBugPayload"}
10263
10264func (ec *executionContext) _OpenBugPayload(ctx context.Context, sel ast.SelectionSet, obj *models.OpenBugPayload) graphql.Marshaler {
10265	fields := graphql.CollectFields(ec.RequestContext, sel, openBugPayloadImplementors)
10266
10267	out := graphql.NewFieldSet(fields)
10268	var invalids uint32
10269	for i, field := range fields {
10270		switch field.Name {
10271		case "__typename":
10272			out.Values[i] = graphql.MarshalString("OpenBugPayload")
10273		case "clientMutationId":
10274			out.Values[i] = ec._OpenBugPayload_clientMutationId(ctx, field, obj)
10275		case "bug":
10276			out.Values[i] = ec._OpenBugPayload_bug(ctx, field, obj)
10277			if out.Values[i] == graphql.Null {
10278				invalids++
10279			}
10280		case "operation":
10281			out.Values[i] = ec._OpenBugPayload_operation(ctx, field, obj)
10282			if out.Values[i] == graphql.Null {
10283				invalids++
10284			}
10285		default:
10286			panic("unknown field " + strconv.Quote(field.Name))
10287		}
10288	}
10289	out.Dispatch()
10290	if invalids > 0 {
10291		return graphql.Null
10292	}
10293	return out
10294}
10295
10296var operationConnectionImplementors = []string{"OperationConnection"}
10297
10298func (ec *executionContext) _OperationConnection(ctx context.Context, sel ast.SelectionSet, obj *models.OperationConnection) graphql.Marshaler {
10299	fields := graphql.CollectFields(ec.RequestContext, sel, operationConnectionImplementors)
10300
10301	out := graphql.NewFieldSet(fields)
10302	var invalids uint32
10303	for i, field := range fields {
10304		switch field.Name {
10305		case "__typename":
10306			out.Values[i] = graphql.MarshalString("OperationConnection")
10307		case "edges":
10308			out.Values[i] = ec._OperationConnection_edges(ctx, field, obj)
10309			if out.Values[i] == graphql.Null {
10310				invalids++
10311			}
10312		case "nodes":
10313			out.Values[i] = ec._OperationConnection_nodes(ctx, field, obj)
10314			if out.Values[i] == graphql.Null {
10315				invalids++
10316			}
10317		case "pageInfo":
10318			out.Values[i] = ec._OperationConnection_pageInfo(ctx, field, obj)
10319			if out.Values[i] == graphql.Null {
10320				invalids++
10321			}
10322		case "totalCount":
10323			out.Values[i] = ec._OperationConnection_totalCount(ctx, field, obj)
10324			if out.Values[i] == graphql.Null {
10325				invalids++
10326			}
10327		default:
10328			panic("unknown field " + strconv.Quote(field.Name))
10329		}
10330	}
10331	out.Dispatch()
10332	if invalids > 0 {
10333		return graphql.Null
10334	}
10335	return out
10336}
10337
10338var operationEdgeImplementors = []string{"OperationEdge"}
10339
10340func (ec *executionContext) _OperationEdge(ctx context.Context, sel ast.SelectionSet, obj *models.OperationEdge) graphql.Marshaler {
10341	fields := graphql.CollectFields(ec.RequestContext, sel, operationEdgeImplementors)
10342
10343	out := graphql.NewFieldSet(fields)
10344	var invalids uint32
10345	for i, field := range fields {
10346		switch field.Name {
10347		case "__typename":
10348			out.Values[i] = graphql.MarshalString("OperationEdge")
10349		case "cursor":
10350			out.Values[i] = ec._OperationEdge_cursor(ctx, field, obj)
10351			if out.Values[i] == graphql.Null {
10352				invalids++
10353			}
10354		case "node":
10355			out.Values[i] = ec._OperationEdge_node(ctx, field, obj)
10356			if out.Values[i] == graphql.Null {
10357				invalids++
10358			}
10359		default:
10360			panic("unknown field " + strconv.Quote(field.Name))
10361		}
10362	}
10363	out.Dispatch()
10364	if invalids > 0 {
10365		return graphql.Null
10366	}
10367	return out
10368}
10369
10370var pageInfoImplementors = []string{"PageInfo"}
10371
10372func (ec *executionContext) _PageInfo(ctx context.Context, sel ast.SelectionSet, obj *models.PageInfo) graphql.Marshaler {
10373	fields := graphql.CollectFields(ec.RequestContext, sel, pageInfoImplementors)
10374
10375	out := graphql.NewFieldSet(fields)
10376	var invalids uint32
10377	for i, field := range fields {
10378		switch field.Name {
10379		case "__typename":
10380			out.Values[i] = graphql.MarshalString("PageInfo")
10381		case "hasNextPage":
10382			out.Values[i] = ec._PageInfo_hasNextPage(ctx, field, obj)
10383			if out.Values[i] == graphql.Null {
10384				invalids++
10385			}
10386		case "hasPreviousPage":
10387			out.Values[i] = ec._PageInfo_hasPreviousPage(ctx, field, obj)
10388			if out.Values[i] == graphql.Null {
10389				invalids++
10390			}
10391		case "startCursor":
10392			out.Values[i] = ec._PageInfo_startCursor(ctx, field, obj)
10393			if out.Values[i] == graphql.Null {
10394				invalids++
10395			}
10396		case "endCursor":
10397			out.Values[i] = ec._PageInfo_endCursor(ctx, field, obj)
10398			if out.Values[i] == graphql.Null {
10399				invalids++
10400			}
10401		default:
10402			panic("unknown field " + strconv.Quote(field.Name))
10403		}
10404	}
10405	out.Dispatch()
10406	if invalids > 0 {
10407		return graphql.Null
10408	}
10409	return out
10410}
10411
10412var queryImplementors = []string{"Query"}
10413
10414func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
10415	fields := graphql.CollectFields(ec.RequestContext, sel, queryImplementors)
10416
10417	ctx = graphql.WithResolverContext(ctx, &graphql.ResolverContext{
10418		Object: "Query",
10419	})
10420
10421	out := graphql.NewFieldSet(fields)
10422	var invalids uint32
10423	for i, field := range fields {
10424		switch field.Name {
10425		case "__typename":
10426			out.Values[i] = graphql.MarshalString("Query")
10427		case "defaultRepository":
10428			field := field
10429			out.Concurrently(i, func() (res graphql.Marshaler) {
10430				defer func() {
10431					if r := recover(); r != nil {
10432						ec.Error(ctx, ec.Recover(ctx, r))
10433					}
10434				}()
10435				res = ec._Query_defaultRepository(ctx, field)
10436				return res
10437			})
10438		case "repository":
10439			field := field
10440			out.Concurrently(i, func() (res graphql.Marshaler) {
10441				defer func() {
10442					if r := recover(); r != nil {
10443						ec.Error(ctx, ec.Recover(ctx, r))
10444					}
10445				}()
10446				res = ec._Query_repository(ctx, field)
10447				return res
10448			})
10449		case "__type":
10450			out.Values[i] = ec._Query___type(ctx, field)
10451		case "__schema":
10452			out.Values[i] = ec._Query___schema(ctx, field)
10453		default:
10454			panic("unknown field " + strconv.Quote(field.Name))
10455		}
10456	}
10457	out.Dispatch()
10458	if invalids > 0 {
10459		return graphql.Null
10460	}
10461	return out
10462}
10463
10464var repositoryImplementors = []string{"Repository"}
10465
10466func (ec *executionContext) _Repository(ctx context.Context, sel ast.SelectionSet, obj *models.Repository) graphql.Marshaler {
10467	fields := graphql.CollectFields(ec.RequestContext, sel, repositoryImplementors)
10468
10469	out := graphql.NewFieldSet(fields)
10470	var invalids uint32
10471	for i, field := range fields {
10472		switch field.Name {
10473		case "__typename":
10474			out.Values[i] = graphql.MarshalString("Repository")
10475		case "allBugs":
10476			field := field
10477			out.Concurrently(i, func() (res graphql.Marshaler) {
10478				defer func() {
10479					if r := recover(); r != nil {
10480						ec.Error(ctx, ec.Recover(ctx, r))
10481					}
10482				}()
10483				res = ec._Repository_allBugs(ctx, field, obj)
10484				if res == graphql.Null {
10485					atomic.AddUint32(&invalids, 1)
10486				}
10487				return res
10488			})
10489		case "bug":
10490			field := field
10491			out.Concurrently(i, func() (res graphql.Marshaler) {
10492				defer func() {
10493					if r := recover(); r != nil {
10494						ec.Error(ctx, ec.Recover(ctx, r))
10495					}
10496				}()
10497				res = ec._Repository_bug(ctx, field, obj)
10498				return res
10499			})
10500		case "allIdentities":
10501			field := field
10502			out.Concurrently(i, func() (res graphql.Marshaler) {
10503				defer func() {
10504					if r := recover(); r != nil {
10505						ec.Error(ctx, ec.Recover(ctx, r))
10506					}
10507				}()
10508				res = ec._Repository_allIdentities(ctx, field, obj)
10509				if res == graphql.Null {
10510					atomic.AddUint32(&invalids, 1)
10511				}
10512				return res
10513			})
10514		case "identity":
10515			field := field
10516			out.Concurrently(i, func() (res graphql.Marshaler) {
10517				defer func() {
10518					if r := recover(); r != nil {
10519						ec.Error(ctx, ec.Recover(ctx, r))
10520					}
10521				}()
10522				res = ec._Repository_identity(ctx, field, obj)
10523				return res
10524			})
10525		case "userIdentity":
10526			field := field
10527			out.Concurrently(i, func() (res graphql.Marshaler) {
10528				defer func() {
10529					if r := recover(); r != nil {
10530						ec.Error(ctx, ec.Recover(ctx, r))
10531					}
10532				}()
10533				res = ec._Repository_userIdentity(ctx, field, obj)
10534				return res
10535			})
10536		case "validLabels":
10537			field := field
10538			out.Concurrently(i, func() (res graphql.Marshaler) {
10539				defer func() {
10540					if r := recover(); r != nil {
10541						ec.Error(ctx, ec.Recover(ctx, r))
10542					}
10543				}()
10544				res = ec._Repository_validLabels(ctx, field, obj)
10545				if res == graphql.Null {
10546					atomic.AddUint32(&invalids, 1)
10547				}
10548				return res
10549			})
10550		default:
10551			panic("unknown field " + strconv.Quote(field.Name))
10552		}
10553	}
10554	out.Dispatch()
10555	if invalids > 0 {
10556		return graphql.Null
10557	}
10558	return out
10559}
10560
10561var setStatusOperationImplementors = []string{"SetStatusOperation", "Operation", "Authored"}
10562
10563func (ec *executionContext) _SetStatusOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.SetStatusOperation) graphql.Marshaler {
10564	fields := graphql.CollectFields(ec.RequestContext, sel, setStatusOperationImplementors)
10565
10566	out := graphql.NewFieldSet(fields)
10567	var invalids uint32
10568	for i, field := range fields {
10569		switch field.Name {
10570		case "__typename":
10571			out.Values[i] = graphql.MarshalString("SetStatusOperation")
10572		case "hash":
10573			out.Values[i] = ec._SetStatusOperation_hash(ctx, field, obj)
10574			if out.Values[i] == graphql.Null {
10575				atomic.AddUint32(&invalids, 1)
10576			}
10577		case "author":
10578			out.Values[i] = ec._SetStatusOperation_author(ctx, field, obj)
10579			if out.Values[i] == graphql.Null {
10580				atomic.AddUint32(&invalids, 1)
10581			}
10582		case "date":
10583			field := field
10584			out.Concurrently(i, func() (res graphql.Marshaler) {
10585				defer func() {
10586					if r := recover(); r != nil {
10587						ec.Error(ctx, ec.Recover(ctx, r))
10588					}
10589				}()
10590				res = ec._SetStatusOperation_date(ctx, field, obj)
10591				if res == graphql.Null {
10592					atomic.AddUint32(&invalids, 1)
10593				}
10594				return res
10595			})
10596		case "status":
10597			field := field
10598			out.Concurrently(i, func() (res graphql.Marshaler) {
10599				defer func() {
10600					if r := recover(); r != nil {
10601						ec.Error(ctx, ec.Recover(ctx, r))
10602					}
10603				}()
10604				res = ec._SetStatusOperation_status(ctx, field, obj)
10605				if res == graphql.Null {
10606					atomic.AddUint32(&invalids, 1)
10607				}
10608				return res
10609			})
10610		default:
10611			panic("unknown field " + strconv.Quote(field.Name))
10612		}
10613	}
10614	out.Dispatch()
10615	if invalids > 0 {
10616		return graphql.Null
10617	}
10618	return out
10619}
10620
10621var setStatusTimelineItemImplementors = []string{"SetStatusTimelineItem", "TimelineItem", "Authored"}
10622
10623func (ec *executionContext) _SetStatusTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.SetStatusTimelineItem) graphql.Marshaler {
10624	fields := graphql.CollectFields(ec.RequestContext, sel, setStatusTimelineItemImplementors)
10625
10626	out := graphql.NewFieldSet(fields)
10627	var invalids uint32
10628	for i, field := range fields {
10629		switch field.Name {
10630		case "__typename":
10631			out.Values[i] = graphql.MarshalString("SetStatusTimelineItem")
10632		case "hash":
10633			out.Values[i] = ec._SetStatusTimelineItem_hash(ctx, field, obj)
10634			if out.Values[i] == graphql.Null {
10635				atomic.AddUint32(&invalids, 1)
10636			}
10637		case "author":
10638			out.Values[i] = ec._SetStatusTimelineItem_author(ctx, field, obj)
10639			if out.Values[i] == graphql.Null {
10640				atomic.AddUint32(&invalids, 1)
10641			}
10642		case "date":
10643			field := field
10644			out.Concurrently(i, func() (res graphql.Marshaler) {
10645				defer func() {
10646					if r := recover(); r != nil {
10647						ec.Error(ctx, ec.Recover(ctx, r))
10648					}
10649				}()
10650				res = ec._SetStatusTimelineItem_date(ctx, field, obj)
10651				if res == graphql.Null {
10652					atomic.AddUint32(&invalids, 1)
10653				}
10654				return res
10655			})
10656		case "status":
10657			field := field
10658			out.Concurrently(i, func() (res graphql.Marshaler) {
10659				defer func() {
10660					if r := recover(); r != nil {
10661						ec.Error(ctx, ec.Recover(ctx, r))
10662					}
10663				}()
10664				res = ec._SetStatusTimelineItem_status(ctx, field, obj)
10665				if res == graphql.Null {
10666					atomic.AddUint32(&invalids, 1)
10667				}
10668				return res
10669			})
10670		default:
10671			panic("unknown field " + strconv.Quote(field.Name))
10672		}
10673	}
10674	out.Dispatch()
10675	if invalids > 0 {
10676		return graphql.Null
10677	}
10678	return out
10679}
10680
10681var setTitleOperationImplementors = []string{"SetTitleOperation", "Operation", "Authored"}
10682
10683func (ec *executionContext) _SetTitleOperation(ctx context.Context, sel ast.SelectionSet, obj *bug.SetTitleOperation) graphql.Marshaler {
10684	fields := graphql.CollectFields(ec.RequestContext, sel, setTitleOperationImplementors)
10685
10686	out := graphql.NewFieldSet(fields)
10687	var invalids uint32
10688	for i, field := range fields {
10689		switch field.Name {
10690		case "__typename":
10691			out.Values[i] = graphql.MarshalString("SetTitleOperation")
10692		case "hash":
10693			out.Values[i] = ec._SetTitleOperation_hash(ctx, field, obj)
10694			if out.Values[i] == graphql.Null {
10695				atomic.AddUint32(&invalids, 1)
10696			}
10697		case "author":
10698			out.Values[i] = ec._SetTitleOperation_author(ctx, field, obj)
10699			if out.Values[i] == graphql.Null {
10700				atomic.AddUint32(&invalids, 1)
10701			}
10702		case "date":
10703			field := field
10704			out.Concurrently(i, func() (res graphql.Marshaler) {
10705				defer func() {
10706					if r := recover(); r != nil {
10707						ec.Error(ctx, ec.Recover(ctx, r))
10708					}
10709				}()
10710				res = ec._SetTitleOperation_date(ctx, field, obj)
10711				if res == graphql.Null {
10712					atomic.AddUint32(&invalids, 1)
10713				}
10714				return res
10715			})
10716		case "title":
10717			out.Values[i] = ec._SetTitleOperation_title(ctx, field, obj)
10718			if out.Values[i] == graphql.Null {
10719				atomic.AddUint32(&invalids, 1)
10720			}
10721		case "was":
10722			out.Values[i] = ec._SetTitleOperation_was(ctx, field, obj)
10723			if out.Values[i] == graphql.Null {
10724				atomic.AddUint32(&invalids, 1)
10725			}
10726		default:
10727			panic("unknown field " + strconv.Quote(field.Name))
10728		}
10729	}
10730	out.Dispatch()
10731	if invalids > 0 {
10732		return graphql.Null
10733	}
10734	return out
10735}
10736
10737var setTitlePayloadImplementors = []string{"SetTitlePayload"}
10738
10739func (ec *executionContext) _SetTitlePayload(ctx context.Context, sel ast.SelectionSet, obj *models.SetTitlePayload) graphql.Marshaler {
10740	fields := graphql.CollectFields(ec.RequestContext, sel, setTitlePayloadImplementors)
10741
10742	out := graphql.NewFieldSet(fields)
10743	var invalids uint32
10744	for i, field := range fields {
10745		switch field.Name {
10746		case "__typename":
10747			out.Values[i] = graphql.MarshalString("SetTitlePayload")
10748		case "clientMutationId":
10749			out.Values[i] = ec._SetTitlePayload_clientMutationId(ctx, field, obj)
10750		case "bug":
10751			out.Values[i] = ec._SetTitlePayload_bug(ctx, field, obj)
10752			if out.Values[i] == graphql.Null {
10753				invalids++
10754			}
10755		case "operation":
10756			out.Values[i] = ec._SetTitlePayload_operation(ctx, field, obj)
10757			if out.Values[i] == graphql.Null {
10758				invalids++
10759			}
10760		default:
10761			panic("unknown field " + strconv.Quote(field.Name))
10762		}
10763	}
10764	out.Dispatch()
10765	if invalids > 0 {
10766		return graphql.Null
10767	}
10768	return out
10769}
10770
10771var setTitleTimelineItemImplementors = []string{"SetTitleTimelineItem", "TimelineItem", "Authored"}
10772
10773func (ec *executionContext) _SetTitleTimelineItem(ctx context.Context, sel ast.SelectionSet, obj *bug.SetTitleTimelineItem) graphql.Marshaler {
10774	fields := graphql.CollectFields(ec.RequestContext, sel, setTitleTimelineItemImplementors)
10775
10776	out := graphql.NewFieldSet(fields)
10777	var invalids uint32
10778	for i, field := range fields {
10779		switch field.Name {
10780		case "__typename":
10781			out.Values[i] = graphql.MarshalString("SetTitleTimelineItem")
10782		case "hash":
10783			out.Values[i] = ec._SetTitleTimelineItem_hash(ctx, field, obj)
10784			if out.Values[i] == graphql.Null {
10785				atomic.AddUint32(&invalids, 1)
10786			}
10787		case "author":
10788			out.Values[i] = ec._SetTitleTimelineItem_author(ctx, field, obj)
10789			if out.Values[i] == graphql.Null {
10790				atomic.AddUint32(&invalids, 1)
10791			}
10792		case "date":
10793			field := field
10794			out.Concurrently(i, func() (res graphql.Marshaler) {
10795				defer func() {
10796					if r := recover(); r != nil {
10797						ec.Error(ctx, ec.Recover(ctx, r))
10798					}
10799				}()
10800				res = ec._SetTitleTimelineItem_date(ctx, field, obj)
10801				if res == graphql.Null {
10802					atomic.AddUint32(&invalids, 1)
10803				}
10804				return res
10805			})
10806		case "title":
10807			out.Values[i] = ec._SetTitleTimelineItem_title(ctx, field, obj)
10808			if out.Values[i] == graphql.Null {
10809				atomic.AddUint32(&invalids, 1)
10810			}
10811		case "was":
10812			out.Values[i] = ec._SetTitleTimelineItem_was(ctx, field, obj)
10813			if out.Values[i] == graphql.Null {
10814				atomic.AddUint32(&invalids, 1)
10815			}
10816		default:
10817			panic("unknown field " + strconv.Quote(field.Name))
10818		}
10819	}
10820	out.Dispatch()
10821	if invalids > 0 {
10822		return graphql.Null
10823	}
10824	return out
10825}
10826
10827var timelineItemConnectionImplementors = []string{"TimelineItemConnection"}
10828
10829func (ec *executionContext) _TimelineItemConnection(ctx context.Context, sel ast.SelectionSet, obj *models.TimelineItemConnection) graphql.Marshaler {
10830	fields := graphql.CollectFields(ec.RequestContext, sel, timelineItemConnectionImplementors)
10831
10832	out := graphql.NewFieldSet(fields)
10833	var invalids uint32
10834	for i, field := range fields {
10835		switch field.Name {
10836		case "__typename":
10837			out.Values[i] = graphql.MarshalString("TimelineItemConnection")
10838		case "edges":
10839			out.Values[i] = ec._TimelineItemConnection_edges(ctx, field, obj)
10840			if out.Values[i] == graphql.Null {
10841				invalids++
10842			}
10843		case "nodes":
10844			out.Values[i] = ec._TimelineItemConnection_nodes(ctx, field, obj)
10845			if out.Values[i] == graphql.Null {
10846				invalids++
10847			}
10848		case "pageInfo":
10849			out.Values[i] = ec._TimelineItemConnection_pageInfo(ctx, field, obj)
10850			if out.Values[i] == graphql.Null {
10851				invalids++
10852			}
10853		case "totalCount":
10854			out.Values[i] = ec._TimelineItemConnection_totalCount(ctx, field, obj)
10855			if out.Values[i] == graphql.Null {
10856				invalids++
10857			}
10858		default:
10859			panic("unknown field " + strconv.Quote(field.Name))
10860		}
10861	}
10862	out.Dispatch()
10863	if invalids > 0 {
10864		return graphql.Null
10865	}
10866	return out
10867}
10868
10869var timelineItemEdgeImplementors = []string{"TimelineItemEdge"}
10870
10871func (ec *executionContext) _TimelineItemEdge(ctx context.Context, sel ast.SelectionSet, obj *models.TimelineItemEdge) graphql.Marshaler {
10872	fields := graphql.CollectFields(ec.RequestContext, sel, timelineItemEdgeImplementors)
10873
10874	out := graphql.NewFieldSet(fields)
10875	var invalids uint32
10876	for i, field := range fields {
10877		switch field.Name {
10878		case "__typename":
10879			out.Values[i] = graphql.MarshalString("TimelineItemEdge")
10880		case "cursor":
10881			out.Values[i] = ec._TimelineItemEdge_cursor(ctx, field, obj)
10882			if out.Values[i] == graphql.Null {
10883				invalids++
10884			}
10885		case "node":
10886			out.Values[i] = ec._TimelineItemEdge_node(ctx, field, obj)
10887			if out.Values[i] == graphql.Null {
10888				invalids++
10889			}
10890		default:
10891			panic("unknown field " + strconv.Quote(field.Name))
10892		}
10893	}
10894	out.Dispatch()
10895	if invalids > 0 {
10896		return graphql.Null
10897	}
10898	return out
10899}
10900
10901var __DirectiveImplementors = []string{"__Directive"}
10902
10903func (ec *executionContext) ___Directive(ctx context.Context, sel ast.SelectionSet, obj *introspection.Directive) graphql.Marshaler {
10904	fields := graphql.CollectFields(ec.RequestContext, sel, __DirectiveImplementors)
10905
10906	out := graphql.NewFieldSet(fields)
10907	var invalids uint32
10908	for i, field := range fields {
10909		switch field.Name {
10910		case "__typename":
10911			out.Values[i] = graphql.MarshalString("__Directive")
10912		case "name":
10913			out.Values[i] = ec.___Directive_name(ctx, field, obj)
10914			if out.Values[i] == graphql.Null {
10915				invalids++
10916			}
10917		case "description":
10918			out.Values[i] = ec.___Directive_description(ctx, field, obj)
10919		case "locations":
10920			out.Values[i] = ec.___Directive_locations(ctx, field, obj)
10921			if out.Values[i] == graphql.Null {
10922				invalids++
10923			}
10924		case "args":
10925			out.Values[i] = ec.___Directive_args(ctx, field, obj)
10926			if out.Values[i] == graphql.Null {
10927				invalids++
10928			}
10929		default:
10930			panic("unknown field " + strconv.Quote(field.Name))
10931		}
10932	}
10933	out.Dispatch()
10934	if invalids > 0 {
10935		return graphql.Null
10936	}
10937	return out
10938}
10939
10940var __EnumValueImplementors = []string{"__EnumValue"}
10941
10942func (ec *executionContext) ___EnumValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.EnumValue) graphql.Marshaler {
10943	fields := graphql.CollectFields(ec.RequestContext, sel, __EnumValueImplementors)
10944
10945	out := graphql.NewFieldSet(fields)
10946	var invalids uint32
10947	for i, field := range fields {
10948		switch field.Name {
10949		case "__typename":
10950			out.Values[i] = graphql.MarshalString("__EnumValue")
10951		case "name":
10952			out.Values[i] = ec.___EnumValue_name(ctx, field, obj)
10953			if out.Values[i] == graphql.Null {
10954				invalids++
10955			}
10956		case "description":
10957			out.Values[i] = ec.___EnumValue_description(ctx, field, obj)
10958		case "isDeprecated":
10959			out.Values[i] = ec.___EnumValue_isDeprecated(ctx, field, obj)
10960			if out.Values[i] == graphql.Null {
10961				invalids++
10962			}
10963		case "deprecationReason":
10964			out.Values[i] = ec.___EnumValue_deprecationReason(ctx, field, obj)
10965		default:
10966			panic("unknown field " + strconv.Quote(field.Name))
10967		}
10968	}
10969	out.Dispatch()
10970	if invalids > 0 {
10971		return graphql.Null
10972	}
10973	return out
10974}
10975
10976var __FieldImplementors = []string{"__Field"}
10977
10978func (ec *executionContext) ___Field(ctx context.Context, sel ast.SelectionSet, obj *introspection.Field) graphql.Marshaler {
10979	fields := graphql.CollectFields(ec.RequestContext, sel, __FieldImplementors)
10980
10981	out := graphql.NewFieldSet(fields)
10982	var invalids uint32
10983	for i, field := range fields {
10984		switch field.Name {
10985		case "__typename":
10986			out.Values[i] = graphql.MarshalString("__Field")
10987		case "name":
10988			out.Values[i] = ec.___Field_name(ctx, field, obj)
10989			if out.Values[i] == graphql.Null {
10990				invalids++
10991			}
10992		case "description":
10993			out.Values[i] = ec.___Field_description(ctx, field, obj)
10994		case "args":
10995			out.Values[i] = ec.___Field_args(ctx, field, obj)
10996			if out.Values[i] == graphql.Null {
10997				invalids++
10998			}
10999		case "type":
11000			out.Values[i] = ec.___Field_type(ctx, field, obj)
11001			if out.Values[i] == graphql.Null {
11002				invalids++
11003			}
11004		case "isDeprecated":
11005			out.Values[i] = ec.___Field_isDeprecated(ctx, field, obj)
11006			if out.Values[i] == graphql.Null {
11007				invalids++
11008			}
11009		case "deprecationReason":
11010			out.Values[i] = ec.___Field_deprecationReason(ctx, field, obj)
11011		default:
11012			panic("unknown field " + strconv.Quote(field.Name))
11013		}
11014	}
11015	out.Dispatch()
11016	if invalids > 0 {
11017		return graphql.Null
11018	}
11019	return out
11020}
11021
11022var __InputValueImplementors = []string{"__InputValue"}
11023
11024func (ec *executionContext) ___InputValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.InputValue) graphql.Marshaler {
11025	fields := graphql.CollectFields(ec.RequestContext, sel, __InputValueImplementors)
11026
11027	out := graphql.NewFieldSet(fields)
11028	var invalids uint32
11029	for i, field := range fields {
11030		switch field.Name {
11031		case "__typename":
11032			out.Values[i] = graphql.MarshalString("__InputValue")
11033		case "name":
11034			out.Values[i] = ec.___InputValue_name(ctx, field, obj)
11035			if out.Values[i] == graphql.Null {
11036				invalids++
11037			}
11038		case "description":
11039			out.Values[i] = ec.___InputValue_description(ctx, field, obj)
11040		case "type":
11041			out.Values[i] = ec.___InputValue_type(ctx, field, obj)
11042			if out.Values[i] == graphql.Null {
11043				invalids++
11044			}
11045		case "defaultValue":
11046			out.Values[i] = ec.___InputValue_defaultValue(ctx, field, obj)
11047		default:
11048			panic("unknown field " + strconv.Quote(field.Name))
11049		}
11050	}
11051	out.Dispatch()
11052	if invalids > 0 {
11053		return graphql.Null
11054	}
11055	return out
11056}
11057
11058var __SchemaImplementors = []string{"__Schema"}
11059
11060func (ec *executionContext) ___Schema(ctx context.Context, sel ast.SelectionSet, obj *introspection.Schema) graphql.Marshaler {
11061	fields := graphql.CollectFields(ec.RequestContext, sel, __SchemaImplementors)
11062
11063	out := graphql.NewFieldSet(fields)
11064	var invalids uint32
11065	for i, field := range fields {
11066		switch field.Name {
11067		case "__typename":
11068			out.Values[i] = graphql.MarshalString("__Schema")
11069		case "types":
11070			out.Values[i] = ec.___Schema_types(ctx, field, obj)
11071			if out.Values[i] == graphql.Null {
11072				invalids++
11073			}
11074		case "queryType":
11075			out.Values[i] = ec.___Schema_queryType(ctx, field, obj)
11076			if out.Values[i] == graphql.Null {
11077				invalids++
11078			}
11079		case "mutationType":
11080			out.Values[i] = ec.___Schema_mutationType(ctx, field, obj)
11081		case "subscriptionType":
11082			out.Values[i] = ec.___Schema_subscriptionType(ctx, field, obj)
11083		case "directives":
11084			out.Values[i] = ec.___Schema_directives(ctx, field, obj)
11085			if out.Values[i] == graphql.Null {
11086				invalids++
11087			}
11088		default:
11089			panic("unknown field " + strconv.Quote(field.Name))
11090		}
11091	}
11092	out.Dispatch()
11093	if invalids > 0 {
11094		return graphql.Null
11095	}
11096	return out
11097}
11098
11099var __TypeImplementors = []string{"__Type"}
11100
11101func (ec *executionContext) ___Type(ctx context.Context, sel ast.SelectionSet, obj *introspection.Type) graphql.Marshaler {
11102	fields := graphql.CollectFields(ec.RequestContext, sel, __TypeImplementors)
11103
11104	out := graphql.NewFieldSet(fields)
11105	var invalids uint32
11106	for i, field := range fields {
11107		switch field.Name {
11108		case "__typename":
11109			out.Values[i] = graphql.MarshalString("__Type")
11110		case "kind":
11111			out.Values[i] = ec.___Type_kind(ctx, field, obj)
11112			if out.Values[i] == graphql.Null {
11113				invalids++
11114			}
11115		case "name":
11116			out.Values[i] = ec.___Type_name(ctx, field, obj)
11117		case "description":
11118			out.Values[i] = ec.___Type_description(ctx, field, obj)
11119		case "fields":
11120			out.Values[i] = ec.___Type_fields(ctx, field, obj)
11121		case "interfaces":
11122			out.Values[i] = ec.___Type_interfaces(ctx, field, obj)
11123		case "possibleTypes":
11124			out.Values[i] = ec.___Type_possibleTypes(ctx, field, obj)
11125		case "enumValues":
11126			out.Values[i] = ec.___Type_enumValues(ctx, field, obj)
11127		case "inputFields":
11128			out.Values[i] = ec.___Type_inputFields(ctx, field, obj)
11129		case "ofType":
11130			out.Values[i] = ec.___Type_ofType(ctx, field, obj)
11131		default:
11132			panic("unknown field " + strconv.Quote(field.Name))
11133		}
11134	}
11135	out.Dispatch()
11136	if invalids > 0 {
11137		return graphql.Null
11138	}
11139	return out
11140}
11141
11142// endregion **************************** object.gotpl ****************************
11143
11144// region    ***************************** type.gotpl *****************************
11145
11146func (ec *executionContext) unmarshalNAddCommentInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentInput(ctx context.Context, v interface{}) (models.AddCommentInput, error) {
11147	return ec.unmarshalInputAddCommentInput(ctx, v)
11148}
11149
11150func (ec *executionContext) marshalNAddCommentOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx context.Context, sel ast.SelectionSet, v bug.AddCommentOperation) graphql.Marshaler {
11151	return ec._AddCommentOperation(ctx, sel, &v)
11152}
11153
11154func (ec *executionContext) marshalNAddCommentOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐAddCommentOperation(ctx context.Context, sel ast.SelectionSet, v *bug.AddCommentOperation) graphql.Marshaler {
11155	if v == nil {
11156		if !ec.HasError(graphql.GetResolverContext(ctx)) {
11157			ec.Errorf(ctx, "must not be null")
11158		}
11159		return graphql.Null
11160	}
11161	return ec._AddCommentOperation(ctx, sel, v)
11162}
11163
11164func (ec *executionContext) marshalNAddCommentPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx context.Context, sel ast.SelectionSet, v models.AddCommentPayload) graphql.Marshaler {
11165	return ec._AddCommentPayload(ctx, sel, &v)
11166}
11167
11168func (ec *executionContext) marshalNAddCommentPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐAddCommentPayload(ctx context.Context, sel ast.SelectionSet, v *models.AddCommentPayload) graphql.Marshaler {
11169	if v == nil {
11170		if !ec.HasError(graphql.GetResolverContext(ctx)) {
11171			ec.Errorf(ctx, "must not be null")
11172		}
11173		return graphql.Null
11174	}
11175	return ec._AddCommentPayload(ctx, sel, v)
11176}
11177
11178func (ec *executionContext) unmarshalNBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
11179	return graphql.UnmarshalBoolean(v)
11180}
11181
11182func (ec *executionContext) marshalNBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
11183	res := graphql.MarshalBoolean(v)
11184	if res == graphql.Null {
11185		if !ec.HasError(graphql.GetResolverContext(ctx)) {
11186			ec.Errorf(ctx, "must not be null")
11187		}
11188	}
11189	return res
11190}
11191
11192func (ec *executionContext) marshalNBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx context.Context, sel ast.SelectionSet, v bug.Snapshot) graphql.Marshaler {
11193	return ec._Bug(ctx, sel, &v)
11194}
11195
11196func (ec *executionContext) marshalNBug2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx context.Context, sel ast.SelectionSet, v []*bug.Snapshot) graphql.Marshaler {
11197	ret := make(graphql.Array, len(v))
11198	var wg sync.WaitGroup
11199	isLen1 := len(v) == 1
11200	if !isLen1 {
11201		wg.Add(len(v))
11202	}
11203	for i := range v {
11204		i := i
11205		rctx := &graphql.ResolverContext{
11206			Index:  &i,
11207			Result: &v[i],
11208		}
11209		ctx := graphql.WithResolverContext(ctx, rctx)
11210		f := func(i int) {
11211			defer func() {
11212				if r := recover(); r != nil {
11213					ec.Error(ctx, ec.Recover(ctx, r))
11214					ret = nil
11215				}
11216			}()
11217			if !isLen1 {
11218				defer wg.Done()
11219			}
11220			ret[i] = ec.marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx, sel, v[i])
11221		}
11222		if isLen1 {
11223			f(i)
11224		} else {
11225			go f(i)
11226		}
11227
11228	}
11229	wg.Wait()
11230	return ret
11231}
11232
11233func (ec *executionContext) marshalNBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx context.Context, sel ast.SelectionSet, v *bug.Snapshot) graphql.Marshaler {
11234	if v == nil {
11235		if !ec.HasError(graphql.GetResolverContext(ctx)) {
11236			ec.Errorf(ctx, "must not be null")
11237		}
11238		return graphql.Null
11239	}
11240	return ec._Bug(ctx, sel, v)
11241}
11242
11243func (ec *executionContext) marshalNBugConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugConnection(ctx context.Context, sel ast.SelectionSet, v models.BugConnection) graphql.Marshaler {
11244	return ec._BugConnection(ctx, sel, &v)
11245}
11246
11247func (ec *executionContext) marshalNBugConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugConnection(ctx context.Context, sel ast.SelectionSet, v *models.BugConnection) graphql.Marshaler {
11248	if v == nil {
11249		if !ec.HasError(graphql.GetResolverContext(ctx)) {
11250			ec.Errorf(ctx, "must not be null")
11251		}
11252		return graphql.Null
11253	}
11254	return ec._BugConnection(ctx, sel, v)
11255}
11256
11257func (ec *executionContext) marshalNBugEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx context.Context, sel ast.SelectionSet, v models.BugEdge) graphql.Marshaler {
11258	return ec._BugEdge(ctx, sel, &v)
11259}
11260
11261func (ec *executionContext) marshalNBugEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx context.Context, sel ast.SelectionSet, v []*models.BugEdge) graphql.Marshaler {
11262	ret := make(graphql.Array, len(v))
11263	var wg sync.WaitGroup
11264	isLen1 := len(v) == 1
11265	if !isLen1 {
11266		wg.Add(len(v))
11267	}
11268	for i := range v {
11269		i := i
11270		rctx := &graphql.ResolverContext{
11271			Index:  &i,
11272			Result: &v[i],
11273		}
11274		ctx := graphql.WithResolverContext(ctx, rctx)
11275		f := func(i int) {
11276			defer func() {
11277				if r := recover(); r != nil {
11278					ec.Error(ctx, ec.Recover(ctx, r))
11279					ret = nil
11280				}
11281			}()
11282			if !isLen1 {
11283				defer wg.Done()
11284			}
11285			ret[i] = ec.marshalNBugEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx, sel, v[i])
11286		}
11287		if isLen1 {
11288			f(i)
11289		} else {
11290			go f(i)
11291		}
11292
11293	}
11294	wg.Wait()
11295	return ret
11296}
11297
11298func (ec *executionContext) marshalNBugEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐBugEdge(ctx context.Context, sel ast.SelectionSet, v *models.BugEdge) graphql.Marshaler {
11299	if v == nil {
11300		if !ec.HasError(graphql.GetResolverContext(ctx)) {
11301			ec.Errorf(ctx, "must not be null")
11302		}
11303		return graphql.Null
11304	}
11305	return ec._BugEdge(ctx, sel, v)
11306}
11307
11308func (ec *executionContext) marshalNChangeLabelPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, v models.ChangeLabelPayload) graphql.Marshaler {
11309	return ec._ChangeLabelPayload(ctx, sel, &v)
11310}
11311
11312func (ec *executionContext) marshalNChangeLabelPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, v *models.ChangeLabelPayload) graphql.Marshaler {
11313	if v == nil {
11314		if !ec.HasError(graphql.GetResolverContext(ctx)) {
11315			ec.Errorf(ctx, "must not be null")
11316		}
11317		return graphql.Null
11318	}
11319	return ec._ChangeLabelPayload(ctx, sel, v)
11320}
11321
11322func (ec *executionContext) unmarshalNCloseBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugInput(ctx context.Context, v interface{}) (models.CloseBugInput, error) {
11323	return ec.unmarshalInputCloseBugInput(ctx, v)
11324}
11325
11326func (ec *executionContext) marshalNCloseBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx context.Context, sel ast.SelectionSet, v models.CloseBugPayload) graphql.Marshaler {
11327	return ec._CloseBugPayload(ctx, sel, &v)
11328}
11329
11330func (ec *executionContext) marshalNCloseBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCloseBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.CloseBugPayload) graphql.Marshaler {
11331	if v == nil {
11332		if !ec.HasError(graphql.GetResolverContext(ctx)) {
11333			ec.Errorf(ctx, "must not be null")
11334		}
11335		return graphql.Null
11336	}
11337	return ec._CloseBugPayload(ctx, sel, v)
11338}
11339
11340func (ec *executionContext) marshalNColor2imageᚋcolorᚐRGBA(ctx context.Context, sel ast.SelectionSet, v color.RGBA) graphql.Marshaler {
11341	return ec._Color(ctx, sel, &v)
11342}
11343
11344func (ec *executionContext) marshalNColor2ᚖimageᚋcolorᚐRGBA(ctx context.Context, sel ast.SelectionSet, v *color.RGBA) graphql.Marshaler {
11345	if v == nil {
11346		if !ec.HasError(graphql.GetResolverContext(ctx)) {
11347			ec.Errorf(ctx, "must not be null")
11348		}
11349		return graphql.Null
11350	}
11351	return ec._Color(ctx, sel, v)
11352}
11353
11354func (ec *executionContext) marshalNComment2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx context.Context, sel ast.SelectionSet, v bug.Comment) graphql.Marshaler {
11355	return ec._Comment(ctx, sel, &v)
11356}
11357
11358func (ec *executionContext) marshalNComment2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx context.Context, sel ast.SelectionSet, v []*bug.Comment) graphql.Marshaler {
11359	ret := make(graphql.Array, len(v))
11360	var wg sync.WaitGroup
11361	isLen1 := len(v) == 1
11362	if !isLen1 {
11363		wg.Add(len(v))
11364	}
11365	for i := range v {
11366		i := i
11367		rctx := &graphql.ResolverContext{
11368			Index:  &i,
11369			Result: &v[i],
11370		}
11371		ctx := graphql.WithResolverContext(ctx, rctx)
11372		f := func(i int) {
11373			defer func() {
11374				if r := recover(); r != nil {
11375					ec.Error(ctx, ec.Recover(ctx, r))
11376					ret = nil
11377				}
11378			}()
11379			if !isLen1 {
11380				defer wg.Done()
11381			}
11382			ret[i] = ec.marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx, sel, v[i])
11383		}
11384		if isLen1 {
11385			f(i)
11386		} else {
11387			go f(i)
11388		}
11389
11390	}
11391	wg.Wait()
11392	return ret
11393}
11394
11395func (ec *executionContext) marshalNComment2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐComment(ctx context.Context, sel ast.SelectionSet, v *bug.Comment) graphql.Marshaler {
11396	if v == nil {
11397		if !ec.HasError(graphql.GetResolverContext(ctx)) {
11398			ec.Errorf(ctx, "must not be null")
11399		}
11400		return graphql.Null
11401	}
11402	return ec._Comment(ctx, sel, v)
11403}
11404
11405func (ec *executionContext) marshalNCommentConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentConnection(ctx context.Context, sel ast.SelectionSet, v models.CommentConnection) graphql.Marshaler {
11406	return ec._CommentConnection(ctx, sel, &v)
11407}
11408
11409func (ec *executionContext) marshalNCommentConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentConnection(ctx context.Context, sel ast.SelectionSet, v *models.CommentConnection) graphql.Marshaler {
11410	if v == nil {
11411		if !ec.HasError(graphql.GetResolverContext(ctx)) {
11412			ec.Errorf(ctx, "must not be null")
11413		}
11414		return graphql.Null
11415	}
11416	return ec._CommentConnection(ctx, sel, v)
11417}
11418
11419func (ec *executionContext) marshalNCommentEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx context.Context, sel ast.SelectionSet, v models.CommentEdge) graphql.Marshaler {
11420	return ec._CommentEdge(ctx, sel, &v)
11421}
11422
11423func (ec *executionContext) marshalNCommentEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx context.Context, sel ast.SelectionSet, v []*models.CommentEdge) graphql.Marshaler {
11424	ret := make(graphql.Array, len(v))
11425	var wg sync.WaitGroup
11426	isLen1 := len(v) == 1
11427	if !isLen1 {
11428		wg.Add(len(v))
11429	}
11430	for i := range v {
11431		i := i
11432		rctx := &graphql.ResolverContext{
11433			Index:  &i,
11434			Result: &v[i],
11435		}
11436		ctx := graphql.WithResolverContext(ctx, rctx)
11437		f := func(i int) {
11438			defer func() {
11439				if r := recover(); r != nil {
11440					ec.Error(ctx, ec.Recover(ctx, r))
11441					ret = nil
11442				}
11443			}()
11444			if !isLen1 {
11445				defer wg.Done()
11446			}
11447			ret[i] = ec.marshalNCommentEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx, sel, v[i])
11448		}
11449		if isLen1 {
11450			f(i)
11451		} else {
11452			go f(i)
11453		}
11454
11455	}
11456	wg.Wait()
11457	return ret
11458}
11459
11460func (ec *executionContext) marshalNCommentEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommentEdge(ctx context.Context, sel ast.SelectionSet, v *models.CommentEdge) graphql.Marshaler {
11461	if v == nil {
11462		if !ec.HasError(graphql.GetResolverContext(ctx)) {
11463			ec.Errorf(ctx, "must not be null")
11464		}
11465		return graphql.Null
11466	}
11467	return ec._CommentEdge(ctx, sel, v)
11468}
11469
11470func (ec *executionContext) marshalNCommentHistoryStep2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx context.Context, sel ast.SelectionSet, v bug.CommentHistoryStep) graphql.Marshaler {
11471	return ec._CommentHistoryStep(ctx, sel, &v)
11472}
11473
11474func (ec *executionContext) marshalNCommentHistoryStep2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx context.Context, sel ast.SelectionSet, v []bug.CommentHistoryStep) graphql.Marshaler {
11475	ret := make(graphql.Array, len(v))
11476	var wg sync.WaitGroup
11477	isLen1 := len(v) == 1
11478	if !isLen1 {
11479		wg.Add(len(v))
11480	}
11481	for i := range v {
11482		i := i
11483		rctx := &graphql.ResolverContext{
11484			Index:  &i,
11485			Result: &v[i],
11486		}
11487		ctx := graphql.WithResolverContext(ctx, rctx)
11488		f := func(i int) {
11489			defer func() {
11490				if r := recover(); r != nil {
11491					ec.Error(ctx, ec.Recover(ctx, r))
11492					ret = nil
11493				}
11494			}()
11495			if !isLen1 {
11496				defer wg.Done()
11497			}
11498			ret[i] = ec.marshalNCommentHistoryStep2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCommentHistoryStep(ctx, sel, v[i])
11499		}
11500		if isLen1 {
11501			f(i)
11502		} else {
11503			go f(i)
11504		}
11505
11506	}
11507	wg.Wait()
11508	return ret
11509}
11510
11511func (ec *executionContext) unmarshalNCommitAsNeededInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitAsNeededInput(ctx context.Context, v interface{}) (models.CommitAsNeededInput, error) {
11512	return ec.unmarshalInputCommitAsNeededInput(ctx, v)
11513}
11514
11515func (ec *executionContext) marshalNCommitAsNeededPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitAsNeededPayload(ctx context.Context, sel ast.SelectionSet, v models.CommitAsNeededPayload) graphql.Marshaler {
11516	return ec._CommitAsNeededPayload(ctx, sel, &v)
11517}
11518
11519func (ec *executionContext) marshalNCommitAsNeededPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitAsNeededPayload(ctx context.Context, sel ast.SelectionSet, v *models.CommitAsNeededPayload) graphql.Marshaler {
11520	if v == nil {
11521		if !ec.HasError(graphql.GetResolverContext(ctx)) {
11522			ec.Errorf(ctx, "must not be null")
11523		}
11524		return graphql.Null
11525	}
11526	return ec._CommitAsNeededPayload(ctx, sel, v)
11527}
11528
11529func (ec *executionContext) unmarshalNCommitInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitInput(ctx context.Context, v interface{}) (models.CommitInput, error) {
11530	return ec.unmarshalInputCommitInput(ctx, v)
11531}
11532
11533func (ec *executionContext) marshalNCommitPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitPayload(ctx context.Context, sel ast.SelectionSet, v models.CommitPayload) graphql.Marshaler {
11534	return ec._CommitPayload(ctx, sel, &v)
11535}
11536
11537func (ec *executionContext) marshalNCommitPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐCommitPayload(ctx context.Context, sel ast.SelectionSet, v *models.CommitPayload) graphql.Marshaler {
11538	if v == nil {
11539		if !ec.HasError(graphql.GetResolverContext(ctx)) {
11540			ec.Errorf(ctx, "must not be null")
11541		}
11542		return graphql.Null
11543	}
11544	return ec._CommitPayload(ctx, sel, v)
11545}
11546
11547func (ec *executionContext) marshalNCreateOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCreateOperation(ctx context.Context, sel ast.SelectionSet, v bug.CreateOperation) graphql.Marshaler {
11548	return ec._CreateOperation(ctx, sel, &v)
11549}
11550
11551func (ec *executionContext) marshalNCreateOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐCreateOperation(ctx context.Context, sel ast.SelectionSet, v *bug.CreateOperation) graphql.Marshaler {
11552	if v == nil {
11553		if !ec.HasError(graphql.GetResolverContext(ctx)) {
11554			ec.Errorf(ctx, "must not be null")
11555		}
11556		return graphql.Null
11557	}
11558	return ec._CreateOperation(ctx, sel, v)
11559}
11560
11561func (ec *executionContext) unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx context.Context, v interface{}) (git.Hash, error) {
11562	var res git.Hash
11563	return res, res.UnmarshalGQL(v)
11564}
11565
11566func (ec *executionContext) marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx context.Context, sel ast.SelectionSet, v git.Hash) graphql.Marshaler {
11567	return v
11568}
11569
11570func (ec *executionContext) unmarshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx context.Context, v interface{}) ([]git.Hash, error) {
11571	var vSlice []interface{}
11572	if v != nil {
11573		if tmp1, ok := v.([]interface{}); ok {
11574			vSlice = tmp1
11575		} else {
11576			vSlice = []interface{}{v}
11577		}
11578	}
11579	var err error
11580	res := make([]git.Hash, len(vSlice))
11581	for i := range vSlice {
11582		res[i], err = ec.unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, vSlice[i])
11583		if err != nil {
11584			return nil, err
11585		}
11586	}
11587	return res, nil
11588}
11589
11590func (ec *executionContext) marshalNHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx context.Context, sel ast.SelectionSet, v []git.Hash) graphql.Marshaler {
11591	ret := make(graphql.Array, len(v))
11592	for i := range v {
11593		ret[i] = ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, sel, v[i])
11594	}
11595
11596	return ret
11597}
11598
11599func (ec *executionContext) marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx context.Context, sel ast.SelectionSet, v identity.Interface) graphql.Marshaler {
11600	return ec._Identity(ctx, sel, &v)
11601}
11602
11603func (ec *executionContext) marshalNIdentity2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx context.Context, sel ast.SelectionSet, v []identity.Interface) graphql.Marshaler {
11604	ret := make(graphql.Array, len(v))
11605	var wg sync.WaitGroup
11606	isLen1 := len(v) == 1
11607	if !isLen1 {
11608		wg.Add(len(v))
11609	}
11610	for i := range v {
11611		i := i
11612		rctx := &graphql.ResolverContext{
11613			Index:  &i,
11614			Result: &v[i],
11615		}
11616		ctx := graphql.WithResolverContext(ctx, rctx)
11617		f := func(i int) {
11618			defer func() {
11619				if r := recover(); r != nil {
11620					ec.Error(ctx, ec.Recover(ctx, r))
11621					ret = nil
11622				}
11623			}()
11624			if !isLen1 {
11625				defer wg.Done()
11626			}
11627			ret[i] = ec.marshalNIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx, sel, v[i])
11628		}
11629		if isLen1 {
11630			f(i)
11631		} else {
11632			go f(i)
11633		}
11634
11635	}
11636	wg.Wait()
11637	return ret
11638}
11639
11640func (ec *executionContext) marshalNIdentityConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx context.Context, sel ast.SelectionSet, v models.IdentityConnection) graphql.Marshaler {
11641	return ec._IdentityConnection(ctx, sel, &v)
11642}
11643
11644func (ec *executionContext) marshalNIdentityConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityConnection(ctx context.Context, sel ast.SelectionSet, v *models.IdentityConnection) graphql.Marshaler {
11645	if v == nil {
11646		if !ec.HasError(graphql.GetResolverContext(ctx)) {
11647			ec.Errorf(ctx, "must not be null")
11648		}
11649		return graphql.Null
11650	}
11651	return ec._IdentityConnection(ctx, sel, v)
11652}
11653
11654func (ec *executionContext) marshalNIdentityEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx context.Context, sel ast.SelectionSet, v models.IdentityEdge) graphql.Marshaler {
11655	return ec._IdentityEdge(ctx, sel, &v)
11656}
11657
11658func (ec *executionContext) marshalNIdentityEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx context.Context, sel ast.SelectionSet, v []*models.IdentityEdge) graphql.Marshaler {
11659	ret := make(graphql.Array, len(v))
11660	var wg sync.WaitGroup
11661	isLen1 := len(v) == 1
11662	if !isLen1 {
11663		wg.Add(len(v))
11664	}
11665	for i := range v {
11666		i := i
11667		rctx := &graphql.ResolverContext{
11668			Index:  &i,
11669			Result: &v[i],
11670		}
11671		ctx := graphql.WithResolverContext(ctx, rctx)
11672		f := func(i int) {
11673			defer func() {
11674				if r := recover(); r != nil {
11675					ec.Error(ctx, ec.Recover(ctx, r))
11676					ret = nil
11677				}
11678			}()
11679			if !isLen1 {
11680				defer wg.Done()
11681			}
11682			ret[i] = ec.marshalNIdentityEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx, sel, v[i])
11683		}
11684		if isLen1 {
11685			f(i)
11686		} else {
11687			go f(i)
11688		}
11689
11690	}
11691	wg.Wait()
11692	return ret
11693}
11694
11695func (ec *executionContext) marshalNIdentityEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐIdentityEdge(ctx context.Context, sel ast.SelectionSet, v *models.IdentityEdge) graphql.Marshaler {
11696	if v == nil {
11697		if !ec.HasError(graphql.GetResolverContext(ctx)) {
11698			ec.Errorf(ctx, "must not be null")
11699		}
11700		return graphql.Null
11701	}
11702	return ec._IdentityEdge(ctx, sel, v)
11703}
11704
11705func (ec *executionContext) unmarshalNInt2int(ctx context.Context, v interface{}) (int, error) {
11706	return graphql.UnmarshalInt(v)
11707}
11708
11709func (ec *executionContext) marshalNInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
11710	res := graphql.MarshalInt(v)
11711	if res == graphql.Null {
11712		if !ec.HasError(graphql.GetResolverContext(ctx)) {
11713			ec.Errorf(ctx, "must not be null")
11714		}
11715	}
11716	return res
11717}
11718
11719func (ec *executionContext) marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx context.Context, sel ast.SelectionSet, v bug.Label) graphql.Marshaler {
11720	return ec._Label(ctx, sel, &v)
11721}
11722
11723func (ec *executionContext) marshalNLabel2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx context.Context, sel ast.SelectionSet, v []bug.Label) graphql.Marshaler {
11724	ret := make(graphql.Array, len(v))
11725	var wg sync.WaitGroup
11726	isLen1 := len(v) == 1
11727	if !isLen1 {
11728		wg.Add(len(v))
11729	}
11730	for i := range v {
11731		i := i
11732		rctx := &graphql.ResolverContext{
11733			Index:  &i,
11734			Result: &v[i],
11735		}
11736		ctx := graphql.WithResolverContext(ctx, rctx)
11737		f := func(i int) {
11738			defer func() {
11739				if r := recover(); r != nil {
11740					ec.Error(ctx, ec.Recover(ctx, r))
11741					ret = nil
11742				}
11743			}()
11744			if !isLen1 {
11745				defer wg.Done()
11746			}
11747			ret[i] = ec.marshalNLabel2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabel(ctx, sel, v[i])
11748		}
11749		if isLen1 {
11750			f(i)
11751		} else {
11752			go f(i)
11753		}
11754
11755	}
11756	wg.Wait()
11757	return ret
11758}
11759
11760func (ec *executionContext) marshalNLabelChangeOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeOperation(ctx context.Context, sel ast.SelectionSet, v bug.LabelChangeOperation) graphql.Marshaler {
11761	return ec._LabelChangeOperation(ctx, sel, &v)
11762}
11763
11764func (ec *executionContext) marshalNLabelChangeOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeOperation(ctx context.Context, sel ast.SelectionSet, v *bug.LabelChangeOperation) graphql.Marshaler {
11765	if v == nil {
11766		if !ec.HasError(graphql.GetResolverContext(ctx)) {
11767			ec.Errorf(ctx, "must not be null")
11768		}
11769		return graphql.Null
11770	}
11771	return ec._LabelChangeOperation(ctx, sel, v)
11772}
11773
11774func (ec *executionContext) marshalNLabelChangeResult2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v []*bug.LabelChangeResult) graphql.Marshaler {
11775	ret := make(graphql.Array, len(v))
11776	var wg sync.WaitGroup
11777	isLen1 := len(v) == 1
11778	if !isLen1 {
11779		wg.Add(len(v))
11780	}
11781	for i := range v {
11782		i := i
11783		rctx := &graphql.ResolverContext{
11784			Index:  &i,
11785			Result: &v[i],
11786		}
11787		ctx := graphql.WithResolverContext(ctx, rctx)
11788		f := func(i int) {
11789			defer func() {
11790				if r := recover(); r != nil {
11791					ec.Error(ctx, ec.Recover(ctx, r))
11792					ret = nil
11793				}
11794			}()
11795			if !isLen1 {
11796				defer wg.Done()
11797			}
11798			ret[i] = ec.marshalOLabelChangeResult2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx, sel, v[i])
11799		}
11800		if isLen1 {
11801			f(i)
11802		} else {
11803			go f(i)
11804		}
11805
11806	}
11807	wg.Wait()
11808	return ret
11809}
11810
11811func (ec *executionContext) unmarshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx context.Context, v interface{}) (models.LabelChangeStatus, error) {
11812	var res models.LabelChangeStatus
11813	return res, res.UnmarshalGQL(v)
11814}
11815
11816func (ec *executionContext) marshalNLabelChangeStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐLabelChangeStatus(ctx context.Context, sel ast.SelectionSet, v models.LabelChangeStatus) graphql.Marshaler {
11817	return v
11818}
11819
11820func (ec *executionContext) unmarshalNNewBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugInput(ctx context.Context, v interface{}) (models.NewBugInput, error) {
11821	return ec.unmarshalInputNewBugInput(ctx, v)
11822}
11823
11824func (ec *executionContext) marshalNNewBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugPayload(ctx context.Context, sel ast.SelectionSet, v models.NewBugPayload) graphql.Marshaler {
11825	return ec._NewBugPayload(ctx, sel, &v)
11826}
11827
11828func (ec *executionContext) marshalNNewBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐNewBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.NewBugPayload) graphql.Marshaler {
11829	if v == nil {
11830		if !ec.HasError(graphql.GetResolverContext(ctx)) {
11831			ec.Errorf(ctx, "must not be null")
11832		}
11833		return graphql.Null
11834	}
11835	return ec._NewBugPayload(ctx, sel, v)
11836}
11837
11838func (ec *executionContext) unmarshalNOpenBugInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugInput(ctx context.Context, v interface{}) (models.OpenBugInput, error) {
11839	return ec.unmarshalInputOpenBugInput(ctx, v)
11840}
11841
11842func (ec *executionContext) marshalNOpenBugPayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx context.Context, sel ast.SelectionSet, v models.OpenBugPayload) graphql.Marshaler {
11843	return ec._OpenBugPayload(ctx, sel, &v)
11844}
11845
11846func (ec *executionContext) marshalNOpenBugPayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOpenBugPayload(ctx context.Context, sel ast.SelectionSet, v *models.OpenBugPayload) graphql.Marshaler {
11847	if v == nil {
11848		if !ec.HasError(graphql.GetResolverContext(ctx)) {
11849			ec.Errorf(ctx, "must not be null")
11850		}
11851		return graphql.Null
11852	}
11853	return ec._OpenBugPayload(ctx, sel, v)
11854}
11855
11856func (ec *executionContext) marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx context.Context, sel ast.SelectionSet, v bug.Operation) graphql.Marshaler {
11857	return ec._Operation(ctx, sel, &v)
11858}
11859
11860func (ec *executionContext) marshalNOperation2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx context.Context, sel ast.SelectionSet, v []bug.Operation) graphql.Marshaler {
11861	ret := make(graphql.Array, len(v))
11862	var wg sync.WaitGroup
11863	isLen1 := len(v) == 1
11864	if !isLen1 {
11865		wg.Add(len(v))
11866	}
11867	for i := range v {
11868		i := i
11869		rctx := &graphql.ResolverContext{
11870			Index:  &i,
11871			Result: &v[i],
11872		}
11873		ctx := graphql.WithResolverContext(ctx, rctx)
11874		f := func(i int) {
11875			defer func() {
11876				if r := recover(); r != nil {
11877					ec.Error(ctx, ec.Recover(ctx, r))
11878					ret = nil
11879				}
11880			}()
11881			if !isLen1 {
11882				defer wg.Done()
11883			}
11884			ret[i] = ec.marshalNOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐOperation(ctx, sel, v[i])
11885		}
11886		if isLen1 {
11887			f(i)
11888		} else {
11889			go f(i)
11890		}
11891
11892	}
11893	wg.Wait()
11894	return ret
11895}
11896
11897func (ec *executionContext) marshalNOperationConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationConnection(ctx context.Context, sel ast.SelectionSet, v models.OperationConnection) graphql.Marshaler {
11898	return ec._OperationConnection(ctx, sel, &v)
11899}
11900
11901func (ec *executionContext) marshalNOperationConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationConnection(ctx context.Context, sel ast.SelectionSet, v *models.OperationConnection) graphql.Marshaler {
11902	if v == nil {
11903		if !ec.HasError(graphql.GetResolverContext(ctx)) {
11904			ec.Errorf(ctx, "must not be null")
11905		}
11906		return graphql.Null
11907	}
11908	return ec._OperationConnection(ctx, sel, v)
11909}
11910
11911func (ec *executionContext) marshalNOperationEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx context.Context, sel ast.SelectionSet, v models.OperationEdge) graphql.Marshaler {
11912	return ec._OperationEdge(ctx, sel, &v)
11913}
11914
11915func (ec *executionContext) marshalNOperationEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx context.Context, sel ast.SelectionSet, v []*models.OperationEdge) graphql.Marshaler {
11916	ret := make(graphql.Array, len(v))
11917	var wg sync.WaitGroup
11918	isLen1 := len(v) == 1
11919	if !isLen1 {
11920		wg.Add(len(v))
11921	}
11922	for i := range v {
11923		i := i
11924		rctx := &graphql.ResolverContext{
11925			Index:  &i,
11926			Result: &v[i],
11927		}
11928		ctx := graphql.WithResolverContext(ctx, rctx)
11929		f := func(i int) {
11930			defer func() {
11931				if r := recover(); r != nil {
11932					ec.Error(ctx, ec.Recover(ctx, r))
11933					ret = nil
11934				}
11935			}()
11936			if !isLen1 {
11937				defer wg.Done()
11938			}
11939			ret[i] = ec.marshalNOperationEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx, sel, v[i])
11940		}
11941		if isLen1 {
11942			f(i)
11943		} else {
11944			go f(i)
11945		}
11946
11947	}
11948	wg.Wait()
11949	return ret
11950}
11951
11952func (ec *executionContext) marshalNOperationEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐOperationEdge(ctx context.Context, sel ast.SelectionSet, v *models.OperationEdge) graphql.Marshaler {
11953	if v == nil {
11954		if !ec.HasError(graphql.GetResolverContext(ctx)) {
11955			ec.Errorf(ctx, "must not be null")
11956		}
11957		return graphql.Null
11958	}
11959	return ec._OperationEdge(ctx, sel, v)
11960}
11961
11962func (ec *executionContext) marshalNPageInfo2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx context.Context, sel ast.SelectionSet, v models.PageInfo) graphql.Marshaler {
11963	return ec._PageInfo(ctx, sel, &v)
11964}
11965
11966func (ec *executionContext) marshalNPageInfo2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐPageInfo(ctx context.Context, sel ast.SelectionSet, v *models.PageInfo) graphql.Marshaler {
11967	if v == nil {
11968		if !ec.HasError(graphql.GetResolverContext(ctx)) {
11969			ec.Errorf(ctx, "must not be null")
11970		}
11971		return graphql.Null
11972	}
11973	return ec._PageInfo(ctx, sel, v)
11974}
11975
11976func (ec *executionContext) marshalNSetStatusOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx context.Context, sel ast.SelectionSet, v bug.SetStatusOperation) graphql.Marshaler {
11977	return ec._SetStatusOperation(ctx, sel, &v)
11978}
11979
11980func (ec *executionContext) marshalNSetStatusOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetStatusOperation(ctx context.Context, sel ast.SelectionSet, v *bug.SetStatusOperation) graphql.Marshaler {
11981	if v == nil {
11982		if !ec.HasError(graphql.GetResolverContext(ctx)) {
11983			ec.Errorf(ctx, "must not be null")
11984		}
11985		return graphql.Null
11986	}
11987	return ec._SetStatusOperation(ctx, sel, v)
11988}
11989
11990func (ec *executionContext) unmarshalNSetTitleInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitleInput(ctx context.Context, v interface{}) (models.SetTitleInput, error) {
11991	return ec.unmarshalInputSetTitleInput(ctx, v)
11992}
11993
11994func (ec *executionContext) marshalNSetTitleOperation2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetTitleOperation(ctx context.Context, sel ast.SelectionSet, v bug.SetTitleOperation) graphql.Marshaler {
11995	return ec._SetTitleOperation(ctx, sel, &v)
11996}
11997
11998func (ec *executionContext) marshalNSetTitleOperation2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSetTitleOperation(ctx context.Context, sel ast.SelectionSet, v *bug.SetTitleOperation) graphql.Marshaler {
11999	if v == nil {
12000		if !ec.HasError(graphql.GetResolverContext(ctx)) {
12001			ec.Errorf(ctx, "must not be null")
12002		}
12003		return graphql.Null
12004	}
12005	return ec._SetTitleOperation(ctx, sel, v)
12006}
12007
12008func (ec *executionContext) marshalNSetTitlePayload2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx context.Context, sel ast.SelectionSet, v models.SetTitlePayload) graphql.Marshaler {
12009	return ec._SetTitlePayload(ctx, sel, &v)
12010}
12011
12012func (ec *executionContext) marshalNSetTitlePayload2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐSetTitlePayload(ctx context.Context, sel ast.SelectionSet, v *models.SetTitlePayload) graphql.Marshaler {
12013	if v == nil {
12014		if !ec.HasError(graphql.GetResolverContext(ctx)) {
12015			ec.Errorf(ctx, "must not be null")
12016		}
12017		return graphql.Null
12018	}
12019	return ec._SetTitlePayload(ctx, sel, v)
12020}
12021
12022func (ec *executionContext) unmarshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx context.Context, v interface{}) (models.Status, error) {
12023	var res models.Status
12024	return res, res.UnmarshalGQL(v)
12025}
12026
12027func (ec *executionContext) marshalNStatus2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐStatus(ctx context.Context, sel ast.SelectionSet, v models.Status) graphql.Marshaler {
12028	return v
12029}
12030
12031func (ec *executionContext) unmarshalNString2string(ctx context.Context, v interface{}) (string, error) {
12032	return graphql.UnmarshalString(v)
12033}
12034
12035func (ec *executionContext) marshalNString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
12036	res := graphql.MarshalString(v)
12037	if res == graphql.Null {
12038		if !ec.HasError(graphql.GetResolverContext(ctx)) {
12039			ec.Errorf(ctx, "must not be null")
12040		}
12041	}
12042	return res
12043}
12044
12045func (ec *executionContext) unmarshalNTime2timeᚐTime(ctx context.Context, v interface{}) (time.Time, error) {
12046	return graphql.UnmarshalTime(v)
12047}
12048
12049func (ec *executionContext) marshalNTime2timeᚐTime(ctx context.Context, sel ast.SelectionSet, v time.Time) graphql.Marshaler {
12050	res := graphql.MarshalTime(v)
12051	if res == graphql.Null {
12052		if !ec.HasError(graphql.GetResolverContext(ctx)) {
12053			ec.Errorf(ctx, "must not be null")
12054		}
12055	}
12056	return res
12057}
12058
12059func (ec *executionContext) unmarshalNTime2ᚖtimeᚐTime(ctx context.Context, v interface{}) (*time.Time, error) {
12060	if v == nil {
12061		return nil, nil
12062	}
12063	res, err := ec.unmarshalNTime2timeᚐTime(ctx, v)
12064	return &res, err
12065}
12066
12067func (ec *executionContext) marshalNTime2ᚖtimeᚐTime(ctx context.Context, sel ast.SelectionSet, v *time.Time) graphql.Marshaler {
12068	if v == nil {
12069		if !ec.HasError(graphql.GetResolverContext(ctx)) {
12070			ec.Errorf(ctx, "must not be null")
12071		}
12072		return graphql.Null
12073	}
12074	return ec.marshalNTime2timeᚐTime(ctx, sel, *v)
12075}
12076
12077func (ec *executionContext) marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx context.Context, sel ast.SelectionSet, v bug.TimelineItem) graphql.Marshaler {
12078	return ec._TimelineItem(ctx, sel, &v)
12079}
12080
12081func (ec *executionContext) marshalNTimelineItem2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx context.Context, sel ast.SelectionSet, v []bug.TimelineItem) graphql.Marshaler {
12082	ret := make(graphql.Array, len(v))
12083	var wg sync.WaitGroup
12084	isLen1 := len(v) == 1
12085	if !isLen1 {
12086		wg.Add(len(v))
12087	}
12088	for i := range v {
12089		i := i
12090		rctx := &graphql.ResolverContext{
12091			Index:  &i,
12092			Result: &v[i],
12093		}
12094		ctx := graphql.WithResolverContext(ctx, rctx)
12095		f := func(i int) {
12096			defer func() {
12097				if r := recover(); r != nil {
12098					ec.Error(ctx, ec.Recover(ctx, r))
12099					ret = nil
12100				}
12101			}()
12102			if !isLen1 {
12103				defer wg.Done()
12104			}
12105			ret[i] = ec.marshalNTimelineItem2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐTimelineItem(ctx, sel, v[i])
12106		}
12107		if isLen1 {
12108			f(i)
12109		} else {
12110			go f(i)
12111		}
12112
12113	}
12114	wg.Wait()
12115	return ret
12116}
12117
12118func (ec *executionContext) marshalNTimelineItemConnection2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx context.Context, sel ast.SelectionSet, v models.TimelineItemConnection) graphql.Marshaler {
12119	return ec._TimelineItemConnection(ctx, sel, &v)
12120}
12121
12122func (ec *executionContext) marshalNTimelineItemConnection2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemConnection(ctx context.Context, sel ast.SelectionSet, v *models.TimelineItemConnection) graphql.Marshaler {
12123	if v == nil {
12124		if !ec.HasError(graphql.GetResolverContext(ctx)) {
12125			ec.Errorf(ctx, "must not be null")
12126		}
12127		return graphql.Null
12128	}
12129	return ec._TimelineItemConnection(ctx, sel, v)
12130}
12131
12132func (ec *executionContext) marshalNTimelineItemEdge2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx context.Context, sel ast.SelectionSet, v models.TimelineItemEdge) graphql.Marshaler {
12133	return ec._TimelineItemEdge(ctx, sel, &v)
12134}
12135
12136func (ec *executionContext) marshalNTimelineItemEdge2ᚕᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx context.Context, sel ast.SelectionSet, v []*models.TimelineItemEdge) graphql.Marshaler {
12137	ret := make(graphql.Array, len(v))
12138	var wg sync.WaitGroup
12139	isLen1 := len(v) == 1
12140	if !isLen1 {
12141		wg.Add(len(v))
12142	}
12143	for i := range v {
12144		i := i
12145		rctx := &graphql.ResolverContext{
12146			Index:  &i,
12147			Result: &v[i],
12148		}
12149		ctx := graphql.WithResolverContext(ctx, rctx)
12150		f := func(i int) {
12151			defer func() {
12152				if r := recover(); r != nil {
12153					ec.Error(ctx, ec.Recover(ctx, r))
12154					ret = nil
12155				}
12156			}()
12157			if !isLen1 {
12158				defer wg.Done()
12159			}
12160			ret[i] = ec.marshalNTimelineItemEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx, sel, v[i])
12161		}
12162		if isLen1 {
12163			f(i)
12164		} else {
12165			go f(i)
12166		}
12167
12168	}
12169	wg.Wait()
12170	return ret
12171}
12172
12173func (ec *executionContext) marshalNTimelineItemEdge2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐTimelineItemEdge(ctx context.Context, sel ast.SelectionSet, v *models.TimelineItemEdge) graphql.Marshaler {
12174	if v == nil {
12175		if !ec.HasError(graphql.GetResolverContext(ctx)) {
12176			ec.Errorf(ctx, "must not be null")
12177		}
12178		return graphql.Null
12179	}
12180	return ec._TimelineItemEdge(ctx, sel, v)
12181}
12182
12183func (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 {
12184	return ec.___Directive(ctx, sel, &v)
12185}
12186
12187func (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 {
12188	ret := make(graphql.Array, len(v))
12189	var wg sync.WaitGroup
12190	isLen1 := len(v) == 1
12191	if !isLen1 {
12192		wg.Add(len(v))
12193	}
12194	for i := range v {
12195		i := i
12196		rctx := &graphql.ResolverContext{
12197			Index:  &i,
12198			Result: &v[i],
12199		}
12200		ctx := graphql.WithResolverContext(ctx, rctx)
12201		f := func(i int) {
12202			defer func() {
12203				if r := recover(); r != nil {
12204					ec.Error(ctx, ec.Recover(ctx, r))
12205					ret = nil
12206				}
12207			}()
12208			if !isLen1 {
12209				defer wg.Done()
12210			}
12211			ret[i] = ec.marshalN__Directive2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx, sel, v[i])
12212		}
12213		if isLen1 {
12214			f(i)
12215		} else {
12216			go f(i)
12217		}
12218
12219	}
12220	wg.Wait()
12221	return ret
12222}
12223
12224func (ec *executionContext) unmarshalN__DirectiveLocation2string(ctx context.Context, v interface{}) (string, error) {
12225	return graphql.UnmarshalString(v)
12226}
12227
12228func (ec *executionContext) marshalN__DirectiveLocation2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
12229	res := graphql.MarshalString(v)
12230	if res == graphql.Null {
12231		if !ec.HasError(graphql.GetResolverContext(ctx)) {
12232			ec.Errorf(ctx, "must not be null")
12233		}
12234	}
12235	return res
12236}
12237
12238func (ec *executionContext) unmarshalN__DirectiveLocation2ᚕstring(ctx context.Context, v interface{}) ([]string, error) {
12239	var vSlice []interface{}
12240	if v != nil {
12241		if tmp1, ok := v.([]interface{}); ok {
12242			vSlice = tmp1
12243		} else {
12244			vSlice = []interface{}{v}
12245		}
12246	}
12247	var err error
12248	res := make([]string, len(vSlice))
12249	for i := range vSlice {
12250		res[i], err = ec.unmarshalN__DirectiveLocation2string(ctx, vSlice[i])
12251		if err != nil {
12252			return nil, err
12253		}
12254	}
12255	return res, nil
12256}
12257
12258func (ec *executionContext) marshalN__DirectiveLocation2ᚕstring(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
12259	ret := make(graphql.Array, len(v))
12260	var wg sync.WaitGroup
12261	isLen1 := len(v) == 1
12262	if !isLen1 {
12263		wg.Add(len(v))
12264	}
12265	for i := range v {
12266		i := i
12267		rctx := &graphql.ResolverContext{
12268			Index:  &i,
12269			Result: &v[i],
12270		}
12271		ctx := graphql.WithResolverContext(ctx, rctx)
12272		f := func(i int) {
12273			defer func() {
12274				if r := recover(); r != nil {
12275					ec.Error(ctx, ec.Recover(ctx, r))
12276					ret = nil
12277				}
12278			}()
12279			if !isLen1 {
12280				defer wg.Done()
12281			}
12282			ret[i] = ec.marshalN__DirectiveLocation2string(ctx, sel, v[i])
12283		}
12284		if isLen1 {
12285			f(i)
12286		} else {
12287			go f(i)
12288		}
12289
12290	}
12291	wg.Wait()
12292	return ret
12293}
12294
12295func (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 {
12296	return ec.___EnumValue(ctx, sel, &v)
12297}
12298
12299func (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 {
12300	return ec.___Field(ctx, sel, &v)
12301}
12302
12303func (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 {
12304	return ec.___InputValue(ctx, sel, &v)
12305}
12306
12307func (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 {
12308	ret := make(graphql.Array, len(v))
12309	var wg sync.WaitGroup
12310	isLen1 := len(v) == 1
12311	if !isLen1 {
12312		wg.Add(len(v))
12313	}
12314	for i := range v {
12315		i := i
12316		rctx := &graphql.ResolverContext{
12317			Index:  &i,
12318			Result: &v[i],
12319		}
12320		ctx := graphql.WithResolverContext(ctx, rctx)
12321		f := func(i int) {
12322			defer func() {
12323				if r := recover(); r != nil {
12324					ec.Error(ctx, ec.Recover(ctx, r))
12325					ret = nil
12326				}
12327			}()
12328			if !isLen1 {
12329				defer wg.Done()
12330			}
12331			ret[i] = ec.marshalN__InputValue2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
12332		}
12333		if isLen1 {
12334			f(i)
12335		} else {
12336			go f(i)
12337		}
12338
12339	}
12340	wg.Wait()
12341	return ret
12342}
12343
12344func (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 {
12345	return ec.___Type(ctx, sel, &v)
12346}
12347
12348func (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 {
12349	ret := make(graphql.Array, len(v))
12350	var wg sync.WaitGroup
12351	isLen1 := len(v) == 1
12352	if !isLen1 {
12353		wg.Add(len(v))
12354	}
12355	for i := range v {
12356		i := i
12357		rctx := &graphql.ResolverContext{
12358			Index:  &i,
12359			Result: &v[i],
12360		}
12361		ctx := graphql.WithResolverContext(ctx, rctx)
12362		f := func(i int) {
12363			defer func() {
12364				if r := recover(); r != nil {
12365					ec.Error(ctx, ec.Recover(ctx, r))
12366					ret = nil
12367				}
12368			}()
12369			if !isLen1 {
12370				defer wg.Done()
12371			}
12372			ret[i] = ec.marshalN__Type2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
12373		}
12374		if isLen1 {
12375			f(i)
12376		} else {
12377			go f(i)
12378		}
12379
12380	}
12381	wg.Wait()
12382	return ret
12383}
12384
12385func (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 {
12386	if v == nil {
12387		if !ec.HasError(graphql.GetResolverContext(ctx)) {
12388			ec.Errorf(ctx, "must not be null")
12389		}
12390		return graphql.Null
12391	}
12392	return ec.___Type(ctx, sel, v)
12393}
12394
12395func (ec *executionContext) unmarshalN__TypeKind2string(ctx context.Context, v interface{}) (string, error) {
12396	return graphql.UnmarshalString(v)
12397}
12398
12399func (ec *executionContext) marshalN__TypeKind2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
12400	res := graphql.MarshalString(v)
12401	if res == graphql.Null {
12402		if !ec.HasError(graphql.GetResolverContext(ctx)) {
12403			ec.Errorf(ctx, "must not be null")
12404		}
12405	}
12406	return res
12407}
12408
12409func (ec *executionContext) unmarshalOBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
12410	return graphql.UnmarshalBoolean(v)
12411}
12412
12413func (ec *executionContext) marshalOBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
12414	return graphql.MarshalBoolean(v)
12415}
12416
12417func (ec *executionContext) unmarshalOBoolean2ᚖbool(ctx context.Context, v interface{}) (*bool, error) {
12418	if v == nil {
12419		return nil, nil
12420	}
12421	res, err := ec.unmarshalOBoolean2bool(ctx, v)
12422	return &res, err
12423}
12424
12425func (ec *executionContext) marshalOBoolean2ᚖbool(ctx context.Context, sel ast.SelectionSet, v *bool) graphql.Marshaler {
12426	if v == nil {
12427		return graphql.Null
12428	}
12429	return ec.marshalOBoolean2bool(ctx, sel, *v)
12430}
12431
12432func (ec *executionContext) marshalOBug2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx context.Context, sel ast.SelectionSet, v bug.Snapshot) graphql.Marshaler {
12433	return ec._Bug(ctx, sel, &v)
12434}
12435
12436func (ec *executionContext) marshalOBug2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐSnapshot(ctx context.Context, sel ast.SelectionSet, v *bug.Snapshot) graphql.Marshaler {
12437	if v == nil {
12438		return graphql.Null
12439	}
12440	return ec._Bug(ctx, sel, v)
12441}
12442
12443func (ec *executionContext) unmarshalOChangeLabelInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx context.Context, v interface{}) (models.ChangeLabelInput, error) {
12444	return ec.unmarshalInputChangeLabelInput(ctx, v)
12445}
12446
12447func (ec *executionContext) unmarshalOChangeLabelInput2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx context.Context, v interface{}) (*models.ChangeLabelInput, error) {
12448	if v == nil {
12449		return nil, nil
12450	}
12451	res, err := ec.unmarshalOChangeLabelInput2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐChangeLabelInput(ctx, v)
12452	return &res, err
12453}
12454
12455func (ec *executionContext) unmarshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx context.Context, v interface{}) ([]git.Hash, error) {
12456	var vSlice []interface{}
12457	if v != nil {
12458		if tmp1, ok := v.([]interface{}); ok {
12459			vSlice = tmp1
12460		} else {
12461			vSlice = []interface{}{v}
12462		}
12463	}
12464	var err error
12465	res := make([]git.Hash, len(vSlice))
12466	for i := range vSlice {
12467		res[i], err = ec.unmarshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, vSlice[i])
12468		if err != nil {
12469			return nil, err
12470		}
12471	}
12472	return res, nil
12473}
12474
12475func (ec *executionContext) marshalOHash2ᚕgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx context.Context, sel ast.SelectionSet, v []git.Hash) graphql.Marshaler {
12476	if v == nil {
12477		return graphql.Null
12478	}
12479	ret := make(graphql.Array, len(v))
12480	for i := range v {
12481		ret[i] = ec.marshalNHash2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋutilᚋgitᚐHash(ctx, sel, v[i])
12482	}
12483
12484	return ret
12485}
12486
12487func (ec *executionContext) marshalOIdentity2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋidentityᚐInterface(ctx context.Context, sel ast.SelectionSet, v identity.Interface) graphql.Marshaler {
12488	return ec._Identity(ctx, sel, &v)
12489}
12490
12491func (ec *executionContext) unmarshalOInt2int(ctx context.Context, v interface{}) (int, error) {
12492	return graphql.UnmarshalInt(v)
12493}
12494
12495func (ec *executionContext) marshalOInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
12496	return graphql.MarshalInt(v)
12497}
12498
12499func (ec *executionContext) unmarshalOInt2ᚖint(ctx context.Context, v interface{}) (*int, error) {
12500	if v == nil {
12501		return nil, nil
12502	}
12503	res, err := ec.unmarshalOInt2int(ctx, v)
12504	return &res, err
12505}
12506
12507func (ec *executionContext) marshalOInt2ᚖint(ctx context.Context, sel ast.SelectionSet, v *int) graphql.Marshaler {
12508	if v == nil {
12509		return graphql.Null
12510	}
12511	return ec.marshalOInt2int(ctx, sel, *v)
12512}
12513
12514func (ec *executionContext) marshalOLabelChangeResult2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v bug.LabelChangeResult) graphql.Marshaler {
12515	return ec._LabelChangeResult(ctx, sel, &v)
12516}
12517
12518func (ec *executionContext) marshalOLabelChangeResult2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋbugᚐLabelChangeResult(ctx context.Context, sel ast.SelectionSet, v *bug.LabelChangeResult) graphql.Marshaler {
12519	if v == nil {
12520		return graphql.Null
12521	}
12522	return ec._LabelChangeResult(ctx, sel, v)
12523}
12524
12525func (ec *executionContext) marshalORepository2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRepository(ctx context.Context, sel ast.SelectionSet, v models.Repository) graphql.Marshaler {
12526	return ec._Repository(ctx, sel, &v)
12527}
12528
12529func (ec *executionContext) marshalORepository2ᚖgithubᚗcomᚋMichaelMureᚋgitᚑbugᚋgraphqlᚋmodelsᚐRepository(ctx context.Context, sel ast.SelectionSet, v *models.Repository) graphql.Marshaler {
12530	if v == nil {
12531		return graphql.Null
12532	}
12533	return ec._Repository(ctx, sel, v)
12534}
12535
12536func (ec *executionContext) unmarshalOString2string(ctx context.Context, v interface{}) (string, error) {
12537	return graphql.UnmarshalString(v)
12538}
12539
12540func (ec *executionContext) marshalOString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
12541	return graphql.MarshalString(v)
12542}
12543
12544func (ec *executionContext) unmarshalOString2ᚕstring(ctx context.Context, v interface{}) ([]string, error) {
12545	var vSlice []interface{}
12546	if v != nil {
12547		if tmp1, ok := v.([]interface{}); ok {
12548			vSlice = tmp1
12549		} else {
12550			vSlice = []interface{}{v}
12551		}
12552	}
12553	var err error
12554	res := make([]string, len(vSlice))
12555	for i := range vSlice {
12556		res[i], err = ec.unmarshalNString2string(ctx, vSlice[i])
12557		if err != nil {
12558			return nil, err
12559		}
12560	}
12561	return res, nil
12562}
12563
12564func (ec *executionContext) marshalOString2ᚕstring(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
12565	if v == nil {
12566		return graphql.Null
12567	}
12568	ret := make(graphql.Array, len(v))
12569	for i := range v {
12570		ret[i] = ec.marshalNString2string(ctx, sel, v[i])
12571	}
12572
12573	return ret
12574}
12575
12576func (ec *executionContext) unmarshalOString2ᚖstring(ctx context.Context, v interface{}) (*string, error) {
12577	if v == nil {
12578		return nil, nil
12579	}
12580	res, err := ec.unmarshalOString2string(ctx, v)
12581	return &res, err
12582}
12583
12584func (ec *executionContext) marshalOString2ᚖstring(ctx context.Context, sel ast.SelectionSet, v *string) graphql.Marshaler {
12585	if v == nil {
12586		return graphql.Null
12587	}
12588	return ec.marshalOString2string(ctx, sel, *v)
12589}
12590
12591func (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 {
12592	if v == nil {
12593		return graphql.Null
12594	}
12595	ret := make(graphql.Array, len(v))
12596	var wg sync.WaitGroup
12597	isLen1 := len(v) == 1
12598	if !isLen1 {
12599		wg.Add(len(v))
12600	}
12601	for i := range v {
12602		i := i
12603		rctx := &graphql.ResolverContext{
12604			Index:  &i,
12605			Result: &v[i],
12606		}
12607		ctx := graphql.WithResolverContext(ctx, rctx)
12608		f := func(i int) {
12609			defer func() {
12610				if r := recover(); r != nil {
12611					ec.Error(ctx, ec.Recover(ctx, r))
12612					ret = nil
12613				}
12614			}()
12615			if !isLen1 {
12616				defer wg.Done()
12617			}
12618			ret[i] = ec.marshalN__EnumValue2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx, sel, v[i])
12619		}
12620		if isLen1 {
12621			f(i)
12622		} else {
12623			go f(i)
12624		}
12625
12626	}
12627	wg.Wait()
12628	return ret
12629}
12630
12631func (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 {
12632	if v == nil {
12633		return graphql.Null
12634	}
12635	ret := make(graphql.Array, len(v))
12636	var wg sync.WaitGroup
12637	isLen1 := len(v) == 1
12638	if !isLen1 {
12639		wg.Add(len(v))
12640	}
12641	for i := range v {
12642		i := i
12643		rctx := &graphql.ResolverContext{
12644			Index:  &i,
12645			Result: &v[i],
12646		}
12647		ctx := graphql.WithResolverContext(ctx, rctx)
12648		f := func(i int) {
12649			defer func() {
12650				if r := recover(); r != nil {
12651					ec.Error(ctx, ec.Recover(ctx, r))
12652					ret = nil
12653				}
12654			}()
12655			if !isLen1 {
12656				defer wg.Done()
12657			}
12658			ret[i] = ec.marshalN__Field2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx, sel, v[i])
12659		}
12660		if isLen1 {
12661			f(i)
12662		} else {
12663			go f(i)
12664		}
12665
12666	}
12667	wg.Wait()
12668	return ret
12669}
12670
12671func (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 {
12672	if v == nil {
12673		return graphql.Null
12674	}
12675	ret := make(graphql.Array, len(v))
12676	var wg sync.WaitGroup
12677	isLen1 := len(v) == 1
12678	if !isLen1 {
12679		wg.Add(len(v))
12680	}
12681	for i := range v {
12682		i := i
12683		rctx := &graphql.ResolverContext{
12684			Index:  &i,
12685			Result: &v[i],
12686		}
12687		ctx := graphql.WithResolverContext(ctx, rctx)
12688		f := func(i int) {
12689			defer func() {
12690				if r := recover(); r != nil {
12691					ec.Error(ctx, ec.Recover(ctx, r))
12692					ret = nil
12693				}
12694			}()
12695			if !isLen1 {
12696				defer wg.Done()
12697			}
12698			ret[i] = ec.marshalN__InputValue2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
12699		}
12700		if isLen1 {
12701			f(i)
12702		} else {
12703			go f(i)
12704		}
12705
12706	}
12707	wg.Wait()
12708	return ret
12709}
12710
12711func (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 {
12712	return ec.___Schema(ctx, sel, &v)
12713}
12714
12715func (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 {
12716	if v == nil {
12717		return graphql.Null
12718	}
12719	return ec.___Schema(ctx, sel, v)
12720}
12721
12722func (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 {
12723	return ec.___Type(ctx, sel, &v)
12724}
12725
12726func (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 {
12727	if v == nil {
12728		return graphql.Null
12729	}
12730	ret := make(graphql.Array, len(v))
12731	var wg sync.WaitGroup
12732	isLen1 := len(v) == 1
12733	if !isLen1 {
12734		wg.Add(len(v))
12735	}
12736	for i := range v {
12737		i := i
12738		rctx := &graphql.ResolverContext{
12739			Index:  &i,
12740			Result: &v[i],
12741		}
12742		ctx := graphql.WithResolverContext(ctx, rctx)
12743		f := func(i int) {
12744			defer func() {
12745				if r := recover(); r != nil {
12746					ec.Error(ctx, ec.Recover(ctx, r))
12747					ret = nil
12748				}
12749			}()
12750			if !isLen1 {
12751				defer wg.Done()
12752			}
12753			ret[i] = ec.marshalN__Type2githubᚗcomᚋMichaelMureᚋgitᚑbugᚋvendorᚋgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
12754		}
12755		if isLen1 {
12756			f(i)
12757		} else {
12758			go f(i)
12759		}
12760
12761	}
12762	wg.Wait()
12763	return ret
12764}
12765
12766func (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 {
12767	if v == nil {
12768		return graphql.Null
12769	}
12770	return ec.___Type(ctx, sel, v)
12771}
12772
12773// endregion ***************************** type.gotpl *****************************